rtm_traverse_narrative

Instructions

Implementation Reference

• src/tools/traverseNarrative.ts:16-75 (handler)

  Main execution logic for the rtm_traverse_narrative tool: builds RTM tree from narrative text, traverses to specified depth, computes recall sequence and statistics, returns JSON-structured content.

  export default async function traverseNarrative(params: TraverseNarrativeParams) {
    try {
      // Create narrative and build tree
      const narrative = createNarrative(params.text, params.title);
      
      const parameters = {
        ...createDefaultParameters(),
        maxBranchingFactor: params.maxBranchingFactor || 4,
        maxRecallDepth: params.maxRecallDepth || 6
      };
      
      const builder = new RTMTreeBuilder(parameters);
      const tree = builder.buildTree(narrative);
      
      // Create clause map for traversal
      const clauseMap = new Map(
        narrative.clauses.map(c => [c.id, c])
      );
      
      // Traverse to specified depth
      const traversal = createTraversal(tree, clauseMap);
      const result = traversal.traverseToDepth(params.traversalDepth);
      
      // Get sequential recall
      const recallSequence = traversal.simulateRecall(params.traversalDepth);
      
      // Get tree statistics
      const treeStats = traversal.getTreeStatistics();
  
      return {
        content: [{
          type: "text",
          text: JSON.stringify({
            success: true,
            treeId: tree.id,
            traversalResult: {
              depth: result.depth,
              nodeCount: result.nodes.length,
              totalClauses: result.totalClauses,
              avgCompressionRatio: result.compressionRatio,
              summaries: result.summary
            },
            recallSequence: recallSequence,
            treeStatistics: treeStats,
            message: `Traversed to depth ${result.depth}, found ${result.nodes.length} nodes covering ${result.totalClauses} clauses`
          }, null, 2)
        }],
      };
    } catch (error) {
      return {
        content: [{
          type: "text",
          text: JSON.stringify({
            success: false,
            error: error instanceof Error ? error.message : "Unknown error occurred"
          }, null, 2)
        }],
      };
    }
  }

• src/schemas/traverseNarrativeSchema.ts:3-9 (schema)

  Zod input schema defining parameters for the tool: text, title, traversalDepth (required), and optional branching/recall parameters.

  export const traverseNarrativeSchema = z.object({
    text: z.string().describe('The narrative text to traverse'),
    title: z.string().describe('Title of the narrative'),
    traversalDepth: z.number().min(1).max(10).describe('Depth to traverse in the tree (controls abstraction level)'),
    maxBranchingFactor: z.number().default(4).describe('Maximum number of child nodes (K parameter)'),
    maxRecallDepth: z.number().default(6).describe('Maximum depth for recall (D parameter)'),
  });

• src/index.ts:47-52 (registration)

  Tool handler registry: maps 'rtm_traverse_narrative' to the traverseNarrative function imported from tools/traverseNarrative.js

  const tools = {
    rtm_create_narrative_tree: createNarrativeTree,
    rtm_generate_ensemble: generateEnsemble,
    rtm_traverse_narrative: traverseNarrative,
    rtm_find_optimal_depth: findOptimalDepth,
  };

• src/index.ts:66-70 (registration)

  Tool metadata registration: defines name, description, and references the input schema for MCP tool listing and validation.

  {
    name: 'rtm_traverse_narrative',
    description: 'Traverse a narrative tree at different depths to get summaries at varying abstraction levels',
    inputSchema: traverseNarrativeSchema,
  },