ctxman 3.1.1 → 3.2.8

package/bin/cm-diagnose.js

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+/**
+ * ctxman diagnose - stack-trace & failure root-cause bundle
+ *
+ * stdout carries the diagnosis document (unless -o/--output or --copy); summary goes to stderr.
+ * Exit codes: 0 done, 1 error, 2 invalid arguments / options.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { getLogger } from '../lib/utils/logger.js';
+
+function printHelp() {
+  process.stdout.write(`ctxman diagnose - root-cause context bundle for stack traces & test failures
+
+Usage: ctxman diagnose [log-file-or-text] [options]
+
+Parses stack trace frames across Node, TS, Python, Go, Rust, Java, C#, Vitest,
+resolves implicated files safely inside the repository (or across multiple
+repositories with --repo), extracts enclosing method code windows, 1-hop graph
+neighbors (across module imports and the AST symbol call graph), and recent
+git history packed within the budget.
+
+Options:
+      --repo DIR           Additional repository root to resolve frames across (repeatable)
+      --stdin              Read failure log or stack trace from stdin
+      --budget TOKENS      Token budget (e.g. 24000, 24k; default: 24000)
+      --format FORMAT      Output format: markdown (default), json, xml
+      --json               Output in JSON format (default: markdown)
+      --calls              Include cross-file AST symbol call graph edges (default)
+      --no-calls           Disable AST symbol call graph edges (module imports only)
+      --no-redact          Do not mask secrets
+  -o, --output FILE        Write output to FILE instead of stdout
+      --copy               Copy document to clipboard
+  -q, --quiet              Do not print summary to stderr
+  -h, --help               Show this help
+
+Examples:
+  ctxman diagnose error.log
+  npm test 2>&1 | ctxman diagnose --stdin
+  ctxman diagnose "Error: invalid token at src/auth.js:42:10" --budget 20k
+  ctxman diagnose "Error at billing-api/src/invoice.js:3:10" --repo ../checkout-web
+  ctxman diagnose failure.txt --json -o diagnosis.json
+`);
+}
+
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString('utf-8');
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv.includes('-h') || argv.includes('--help')) {
+    printHelp();
+    return;
+  }
+
+  getLogger({ level: process.env.LOG_LEVEL || 'error', logToFile: false });
+  console.log = console.info = console.debug = console.error;
+
+  const { diagnoseFailure } = await import('../lib/diagnose/index.js');
+  const { parseBudget } = await import('../lib/task/index.js');
+
+  let inputArg = null;
+  let root = process.cwd();
+  const repos = [];
+  let useStdin = false;
+  let budget = 24000;
+  let format = 'markdown';
+  let callGraph = true;
+  let redact = true;
+  let outputFile = null;
+  let copy = false;
+  let quiet = false;
+
+  try {
+    for (let i = 0; i < argv.length; i++) {
+      const arg = argv[i];
+
+      if (arg === '--stdin') {
+        useStdin = true;
+      } else if (arg === '--root' || arg === '-r') {
+        if (i + 1 >= argv.length) throw new Error('--root needs a directory path');
+        root = path.resolve(argv[++i]);
+      } else if (arg.startsWith('--root=')) {
+        root = path.resolve(arg.slice('--root='.length));
+      } else if (arg === '--repo') {
+        if (i + 1 >= argv.length) throw new Error('--repo needs a directory path');
+        repos.push(path.resolve(argv[++i]));
+      } else if (arg.startsWith('--repo=')) {
+        const val = arg.slice('--repo='.length);
+        if (!val) throw new Error('--repo needs a directory path');
+        repos.push(path.resolve(val));
+      } else if (arg === '--budget') {
+        budget = parseBudget(argv[++i]);
+      } else if (arg.startsWith('--budget=')) {
+        budget = parseBudget(arg.slice('--budget='.length));
+      } else if (arg === '--format') {
+        format = argv[++i];
+      } else if (arg.startsWith('--format=')) {
+        format = arg.slice('--format='.length);
+      } else if (arg === '--json') {
+        format = 'json';
+      } else if (arg === '--calls' || arg === '--call-graph') {
+        callGraph = true;
+      } else if (arg === '--no-calls' || arg === '--no-call-graph') {
+        callGraph = false;
+      } else if (arg === '--no-redact') {
+        redact = false;
+      } else if (arg === '-o' || arg === '--output') {
+        outputFile = argv[++i];
+      } else if (arg.startsWith('-o=')) {
+        outputFile = arg.slice('-o='.length);
+      } else if (arg.startsWith('--output=')) {
+        outputFile = arg.slice('--output='.length);
+      } else if (arg === '--copy') {
+        copy = true;
+      } else if (arg === '-q' || arg === '--quiet') {
+        quiet = true;
+      } else if (!arg.startsWith('-')) {
+        if (inputArg === null) {
+          inputArg = arg;
+        } else {
+          inputArg += ` ${arg}`;
+        }
+      } else {
+        process.stderr.write(`Unknown option: ${arg}\n`);
+        process.exitCode = 2;
+        return;
+      }
+    }
+  } catch (error) {
+    process.stderr.write(`Error: ${error.message}\n`);
+    process.exitCode = 2;
+    return;
+  }
+
+  let traceText = '';
+  if (useStdin || (!inputArg && !process.stdin.isTTY)) {
+    traceText = await readStdin();
+  } else if (inputArg) {
+    if (fs.existsSync(inputArg) && fs.statSync(inputArg).isFile()) {
+      traceText = fs.readFileSync(inputArg, 'utf-8');
+    } else {
+      traceText = inputArg;
+    }
+  }
+
+  if (!traceText || !traceText.trim()) {
+    process.stderr.write('Error: Failure log or stack trace is required.\n');
+    process.exitCode = 2;
+    return;
+  }
+
+  try {
+    const result = await diagnoseFailure(root, traceText, {
+      repos,
+      budget,
+      format,
+      callGraph,
+      redact,
+      output: outputFile,
+    });
+
+    if (copy) {
+      const { default: ClipboardUtils } = await import('../lib/utils/clipboard-utils.js');
+      await ClipboardUtils.copy(result.text);
+      if (!quiet) {
+        process.stderr.write(`Copied ${result.totalTokens} tokens to clipboard.\n`);
+      }
+    } else if (!outputFile) {
+      process.stdout.write(result.text + (result.text.endsWith('\n') ? '' : '\n'));
+    }
+
+    if (!quiet) {
+      const repoLabel = result.repos?.length > 1 ? ` across ${result.repos.length} repos` : '';
+      process.stderr.write(
+        `Diagnosed: ${result.implicatedFiles.length} implicated file(s)${repoLabel}, ${result.totalTokens}/${result.budget} tokens.\n`
+      );
+      if (outputFile) {
+        process.stderr.write(`Saved to: ${outputFile}\n`);
+      }
+    }
+  } catch (error) {
+    process.stderr.write(`Error: ${error.message}\n`);
+    process.exitCode = error.exitCode ?? 1;
+  }
+}
+
+process.stdout.on('error', (error) => {
+  if (error.code !== 'EPIPE') throw error;
+  process.exit(process.exitCode ?? 0);
+});
+
+main();

package/bin/cm-focus.js

@@ -0,0 +1,322 @@
+#!/usr/bin/env node
+/**
+ * ctxman focus - pack a target file (or file:symbol) and its import/call neighborhood
+ *
+ * stdout carries only the document (unless -o/--copy); summary and notices go to stderr.
+ * Exit codes: 0 done, 1 error, 2 invalid policy / exceeds --max-tokens, 3 refused by policy.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { getLogger } from '../lib/utils/logger.js';
+
+const STYLES = ['xml', 'markdown', 'plain', 'json'];
+const EXIT_TOO_LARGE = 2;
+
+function printHelp() {
+  process.stdout.write(`ctxman focus - pack a file (or file:symbol) and its import/call neighborhood
+
+Usage: ctxman focus <file[:symbol]> [root] [options]
+
+Resolves <file> inside the project (default root: current directory) or across a
+multi-repository workspace (--repo), traverses the repository import graph and
+cross-file AST symbol call graph up to --depth hops (both outgoing imports/calls
+and incoming importers/callers by default), and packs the target file first
+followed by its closest neighbors.
+
+Graph Neighborhood:
+      --repo DIR           Additional repository root for cross-repo neighborhood (repeatable)
+  -d, --depth N            Hops in the import/call graph (default: 1; 0 = target file only)
+  -s, --symbol NAME        Focus the cross-file call graph around a specific function/method
+      --imports-only       Follow only outgoing imports/callees (dependencies of <file>)
+      --importers-only     Follow only incoming importers/callers (files depending on <file>)
+      --calls-only         Follow only outgoing cross-file function calls
+      --callers-only       Follow only incoming cross-file function callers
+      --no-calls           Disable cross-file AST call graph edges (module imports only)
+      --no-imports         Same as --importers-only
+      --no-importers       Same as --imports-only
+      --no-tests           Exclude test/spec files from the neighborhood
+
+Document & Size:
+      --budget TOKENS      Token limit (e.g. 20000 or 20k); target first, closest hops next
+      --max-tokens TOKENS  Exit with code 2, writing nothing, when the document is larger
+      --style STYLE        xml (default), markdown, plain, json
+      --json               Same as --style json
+      --no-tree            Leave out the directory tree
+      --header TEXT        Text at the top
+      --instructions FILE  Append the text of FILE at the end, after the files
+      --line-numbers       Number every line
+      --compress           Keep signatures, replace function bodies with placeholders
+      --no-redact          Do not mask secrets
+      --target-model ID    Count with this model's tokenizer encoding and report fit
+
+Output:
+  -o, --output FILE        Write to FILE instead of stdout
+      --copy               Copy to the clipboard instead of stdout
+  -q, --quiet              No summary on stderr
+  -h, --help               Show this help
+
+Examples:
+  ctxman focus src/auth/login.ts
+  ctxman focus src/auth/login.ts:authenticate --depth 2
+  ctxman focus billing-api/src/invoice.js --repo ../checkout-web --depth 2
+  ctxman focus src/auth/login.ts --depth 2 --budget 25k --style markdown
+  ctxman focus lib/pack/index.js --imports-only --compress --copy
+  ctxman focus src/billing.js --no-tests -o focus-billing.xml
+`);
+}
+
+function parseTokens(text, flag) {
+  const match = /^(\d+(?:\.\d+)?)([km])?$/i.exec(String(text).trim());
+  const scale = { k: 1e3, m: 1e6 }[match?.[2]?.toLowerCase()] ?? 1;
+  const value = match ? Math.round(Number(match[1]) * scale) : NaN;
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`${flag} needs a positive number of tokens (e.g. 20000 or 20k), got ${text}`);
+  }
+  return value;
+}
+
+function parseDepth(text) {
+  const value = Number(String(text).trim());
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`--depth needs a non-negative integer, got ${text}`);
+  }
+  return value;
+}
+
+const VALUE_OPTIONS = {
+  '--root': 'root',
+  '-r': 'root',
+  '--repo': 'repos',
+  '--depth': 'depth',
+  '-d': 'depth',
+  '--symbol': 'symbol',
+  '-s': 'symbol',
+  '--budget': 'budget',
+  '--max-tokens': 'maxTokens',
+  '--style': 'style',
+  '--header': 'header',
+  '--instructions': 'instructions',
+  '--target-model': 'targetModel',
+  '--output': 'output',
+  '-o': 'output',
+};
+
+const FLAG_OPTIONS = {
+  '--imports-only': ['importers', false],
+  '--importers-only': ['imports', false],
+  '--calls-only': ['direction', 'calls'],
+  '--callers-only': ['direction', 'callers'],
+  '--calls': ['callGraph', true],
+  '--no-calls': ['callGraph', false],
+  '--no-imports': ['imports', false],
+  '--no-importers': ['importers', false],
+  '--no-tests': ['includeTests', false],
+  '--json': ['style', 'json'],
+  '--tree': ['tree', true],
+  '--no-tree': ['tree', false],
+  '--line-numbers': ['lineNumbers', true],
+  '--compress': ['compress', true],
+  '--redact': ['redact', true],
+  '--no-redact': ['redact', false],
+  '--copy': ['copy', true],
+  '--quiet': ['quiet', true],
+  '-q': ['quiet', true],
+  '--help': ['help', true],
+  '-h': ['help', true],
+};
+
+export function parseFocusArgs(argv) {
+  const options = {
+    repos: [],
+    depth: 1,
+    imports: true,
+    importers: true,
+    callGraph: true,
+    includeTests: true,
+    tree: true,
+    redact: true,
+    positional: [],
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--') {
+      options.positional.push(...argv.slice(i + 1));
+      break;
+    }
+    const eq = arg.startsWith('--') ? arg.indexOf('=') : -1;
+    const name = eq > 0 ? arg.slice(0, eq) : arg;
+    if (VALUE_OPTIONS[name]) {
+      let value;
+      if (eq > 0) value = arg.slice(eq + 1);
+      else if (i + 1 < argv.length) value = argv[++i];
+      else throw new Error(`${name} needs a value`);
+      const key = VALUE_OPTIONS[name];
+      if (key === 'repos') {
+        options.repos.push(value);
+      } else {
+        options[key] = value;
+      }
+    } else if (FLAG_OPTIONS[name] && eq < 0) {
+      const [key, value] = FLAG_OPTIONS[name];
+      options[key] = value;
+    } else if (arg.startsWith('-') && arg !== '-') {
+      throw new Error(`Unknown option: ${arg}`);
+    } else {
+      options.positional.push(arg);
+    }
+  }
+
+  if (options.help) return options;
+
+  if (options.positional.length === 0) {
+    throw new Error('Missing target <file>');
+  }
+  if (options.positional.length > 2) {
+    throw new Error(
+      `Expected <file> [root], got ${options.positional.length} positional arguments`
+    );
+  }
+
+  options.depth = parseDepth(options.depth);
+  if (!options.imports && !options.importers && !options.direction && options.depth > 0) {
+    throw new Error(
+      'Cannot disable both --imports and --importers (use --depth 0 for target only)'
+    );
+  }
+  if (options.style !== undefined && !STYLES.includes(options.style)) {
+    throw new Error(`--style must be one of ${STYLES.join(', ')}`);
+  }
+  if (options.budget !== undefined) options.budget = parseTokens(options.budget, '--budget');
+  if (options.maxTokens !== undefined) {
+    options.maxTokens = parseTokens(options.maxTokens, '--max-tokens');
+  }
+
+  return options;
+}
+
+const formatNumber = (n) => Number(n).toLocaleString('en-US');
+
+function display(file) {
+  const relative = path.relative(process.cwd(), file);
+  return relative && !relative.startsWith('..') && !path.isAbsolute(relative) ? relative : file;
+}
+
+function printSummary(result, extras) {
+  const { focus } = result;
+  const packedNeighbors = Math.max(0, result.files.length - 1);
+  const targetLabel = focus.symbol ? `${focus.target}:${focus.symbol}` : focus.target;
+  const repoLabel =
+    result.repos?.length > 1 ? ` across ${formatNumber(result.repos.length)} repos` : '';
+  const lines = [
+    `ctxman focus: ${targetLabel} + ${formatNumber(packedNeighbors)}/${formatNumber(focus.neighbors.length)} neighbor(s)${repoLabel} ` +
+      `(depth ${focus.depth}, ${focus.direction}), ${formatNumber(result.totalTokens)} tokens (${result.style}, ${result.encoding})`,
+  ];
+  if (result.budget) {
+    const omitted = result.omitted.length;
+    lines.push(
+      `  Budget ${formatNumber(result.budget.limit)}: ${formatNumber(result.budget.used)} used` +
+        (omitted ? `; ${formatNumber(omitted)} neighbor(s) left out` : '; every file fits')
+    );
+  }
+  if (result.compression) {
+    lines.push(
+      `  Compressed ${formatNumber(result.compression.bodies)} function bodies: ` +
+        `${formatNumber(result.compression.savedTokens)} tokens saved`
+    );
+  }
+  if (result.redactions.total) {
+    lines.push(`  Redacted ${formatNumber(result.redactions.total)} secret(s)`);
+  }
+  lines.push(...extras.map((line) => `  ${line}`));
+  process.stderr.write(`${lines.join('\n')}\n`);
+}
+
+async function main() {
+  let args;
+  try {
+    args = parseFocusArgs(process.argv.slice(2));
+  } catch (error) {
+    process.stderr.write(`Error: ${error.message}\nRun "ctxman focus --help" for usage.\n`);
+    process.exitCode = 1;
+    return;
+  }
+  if (args.help) {
+    printHelp();
+    return;
+  }
+
+  getLogger({ level: process.env.LOG_LEVEL || 'warn', logToFile: false });
+  console.log = console.info = console.debug = console.error;
+
+  try {
+    const { focusContext } = await import('../lib/focus/index.js');
+    const [target, explicitRoot] = args.positional;
+    const root = path.resolve(args.root ?? explicitRoot ?? '.');
+    const output = args.output ? path.resolve(args.output) : null;
+
+    const options = {
+      repos: args.repos.map((r) => path.resolve(r)),
+      depth: args.depth,
+      symbol: args.symbol,
+      direction: args.direction,
+      imports: args.imports,
+      importers: args.importers,
+      callGraph: args.callGraph,
+      includeTests: args.includeTests,
+      cwd: args.root || explicitRoot ? root : process.cwd(),
+      style: args.style,
+      tree: args.tree,
+      header: args.header,
+      lineNumbers: args.lineNumbers,
+      compress: args.compress,
+      redact: args.redact,
+      budget: args.budget,
+      targetModel: args.targetModel,
+      excludeFiles: output ? [output] : [],
+    };
+    if (args.instructions !== undefined) {
+      options.instructions = fs.readFileSync(path.resolve(args.instructions), 'utf8');
+    }
+
+    const result = await focusContext(root, target, options);
+    const extras = [];
+
+    if (args.maxTokens && result.totalTokens > args.maxTokens) {
+      if (!args.quiet) printSummary(result, extras);
+      process.stderr.write(
+        `Error: the document has ${formatNumber(result.totalTokens)} tokens, more than ` +
+          `--max-tokens ${formatNumber(args.maxTokens)}; nothing was written.\n`
+      );
+      process.exitCode = EXIT_TOO_LARGE;
+      return;
+    }
+
+    let toStdout = !output && !args.copy;
+    if (output) {
+      fs.mkdirSync(path.dirname(output), { recursive: true });
+      fs.writeFileSync(output, result.text);
+      extras.push(`Written to ${display(output)}`);
+    }
+    if (args.copy) {
+      const { default: ClipboardUtils } = await import('../lib/utils/clipboard-utils.js');
+      if (!ClipboardUtils.copy(result.text) && !output) {
+        extras.push('Clipboard unavailable; writing to stdout instead');
+        toStdout = true;
+      }
+    }
+    if (toStdout) process.stdout.write(result.text);
+    if (!args.quiet) printSummary(result, extras);
+  } catch (error) {
+    process.stderr.write(`Error: ${error.message}\n`);
+    process.exitCode = error.exitCode ?? 1;
+  }
+}
+
+process.stdout.on('error', (error) => {
+  if (error.code !== 'EPIPE') throw error;
+  process.exit(process.exitCode ?? 0);
+});
+
+main();

package/bin/cm-map.js

@@ -25,8 +25,10 @@ are listed with one line per function (line, signature, tokens) until the budget
 
 Options:
   -t, --tokens N           Token budget for the map (default: 2048)
-  -f, --focus PATH         Bias the ranking toward a file or folder and its neighbours
-                           (repeatable)
+      --repo DIR           Additional repository root for a multi-repo workspace map
+                           under one shared token budget (repeatable)
+  -f, --focus PATH         Bias the ranking toward a file, file:symbol, or folder and its
+                           neighbours (repeatable)
       --history N          Commits of git history to mine for change frequency
                            (default: 300, 0 disables)
       --order rank|path    Order of the files in the output (default: rank)
@@ -34,6 +36,7 @@ Options:
       --style STYLE        text (default), markdown, json, dot (Graphviz)
       --json               Same as --style json
       --graph              Print the dependency edges instead of the map
+  -c, --call-graph         Include cross-file AST symbol call graph edges
   -o, --output FILE        Write to FILE instead of stdout
       --copy               Copy to the clipboard instead of stdout
       --no-redact          Do not mask secrets in signatures
@@ -47,6 +50,9 @@ Score:
 Examples:
   ctxman map                                # map of the current directory, 2048 tokens
   ctxman map --tokens 4096 --style markdown
+  ctxman map --call-graph                   # annotate methods with cross-file call targets
+  ctxman map --graph --call-graph           # print both import and symbol call edges
+  ctxman map --repo ../api --repo ../web --tokens 4096
   ctxman map src --focus src/server.js      # around the file you are working on
   ctxman map --important-last -o map.txt    # best files last, next to your question
   ctxman map --graph --style dot | dot -Tsvg > deps.svg
@@ -61,6 +67,7 @@ Examples:
 function parseArgs(argv) {
   const options = {
     root: null,
+    repos: [],
     tokens: undefined,
     focus: [],
     history: undefined,
@@ -68,6 +75,7 @@ function parseArgs(argv) {
     importantLast: false,
     style: undefined,
     graph: false,
+    callGraph: false,
     output: null,
     copy: false,
     redact: true,
@@ -103,6 +111,9 @@ function parseArgs(argv) {
       case '--tokens':
         options.tokens = integer(arg, value(), 1);
         break;
+      case '--repo':
+        options.repos.push(value());
+        break;
       case '-f':
       case '--focus':
         options.focus.push(value());
@@ -131,6 +142,10 @@ function parseArgs(argv) {
       case '--graph':
         options.graph = true;
         break;
+      case '-c':
+      case '--call-graph':
+        options.callGraph = true;
+        break;
       case '-o':
       case '--output':
         options.output = value();
@@ -159,12 +174,22 @@ function parseArgs(argv) {
 
 /**
  * A focus path is project-relative when it exists under the project, otherwise taken
- * from the current directory (`ctxman map ../app --focus ../app/src/a.js`)
+ * from the current directory (`ctxman map ../app --focus ../app/src/a.js`). Preserves
+ * an optional `:symbol` suffix.
  */
 function focusPath(root, entry) {
-  if (path.isAbsolute(entry) || fs.existsSync(path.resolve(root, entry))) return entry;
-  const fromCwd = path.resolve(entry);
-  return fs.existsSync(fromCwd) ? fromCwd : entry;
+  const lastColon = entry.lastIndexOf(':');
+  let pathPart = entry;
+  let symbolSuffix = '';
+  if (lastColon > 1 && !fs.existsSync(path.resolve(root, entry))) {
+    pathPart = entry.slice(0, lastColon);
+    symbolSuffix = entry.slice(lastColon);
+  }
+  if (path.isAbsolute(pathPart) || fs.existsSync(path.resolve(root, pathPart))) {
+    return `${pathPart}${symbolSuffix}`;
+  }
+  const fromCwd = path.resolve(pathPart);
+  return fs.existsSync(fromCwd) ? `${fromCwd}${symbolSuffix}` : entry;
 }
 
 function formatMs(ms) {
@@ -191,19 +216,40 @@ async function main() {
   getLogger({ level: process.env.LOG_LEVEL || 'warn', logToFile: false });
   console.log = console.info = console.debug = console.error;
   const { renderRepoMap } = await import('../lib/map/index.js');
+  const { mapWorkspace } = await import('../lib/workspace/index.js');
   const { default: ClipboardUtils } = await import('../lib/utils/clipboard-utils.js');
 
-  const root = path.resolve(options.root ?? '.');
-  const result = renderRepoMap(root, {
-    tokens: options.tokens,
-    focus: options.focus.map((entry) => focusPath(root, entry)),
-    history: options.history,
-    order: options.order,
-    importantLast: options.importantLast,
-    style: options.style,
-    graph: options.graph,
-    redact: options.redact,
-  });
+  let result;
+  if (options.repos.length > 0) {
+    const repoList = [
+      ...(options.root !== null ? [path.resolve(options.root)] : []),
+      ...options.repos.map((r) => path.resolve(r)),
+    ];
+    result = mapWorkspace(repoList, {
+      tokens: options.tokens,
+      focus: options.focus,
+      history: options.history,
+      order: options.order,
+      importantLast: options.importantLast,
+      style: options.style,
+      graph: options.graph,
+      callGraph: options.callGraph,
+      redact: options.redact,
+    });
+  } else {
+    const root = path.resolve(options.root ?? '.');
+    result = renderRepoMap(root, {
+      tokens: options.tokens,
+      focus: options.focus.map((entry) => focusPath(root, entry)),
+      history: options.history,
+      order: options.order,
+      importantLast: options.importantLast,
+      style: options.style,
+      graph: options.graph,
+      callGraph: options.callGraph,
+      redact: options.redact,
+    });
+  }
 
   if (options.output) {
     fs.writeFileSync(options.output, result.output);
@@ -219,12 +265,19 @@ async function main() {
   for (const warning of result.warnings) console.error(`warning: ${warning}`);
   const { stats } = result;
   const parts = [];
+  if (result.repos?.length > 1) parts.push(`${result.repos.length} repos`);
   if (options.graph || result.style === 'dot') {
     parts.push(`${stats.edges} edges between ${stats.files} files`);
+    if (options.callGraph && stats.callEdges !== undefined) {
+      parts.push(`${stats.callEdges} call edges`);
+    }
   } else {
     parts.push(`${result.files.length} of ${stats.files} files`);
     parts.push(`${result.tokens}/${result.budget} tokens`);
     parts.push(`${stats.edges} import edges`);
+    if (options.callGraph && stats.callEdges !== undefined) {
+      parts.push(`${stats.callEdges} call edges`);
+    }
   }
   const history = result.graph.history;
   if (history.available) parts.push(`history ${history.commits} commits`);
@@ -232,7 +285,7 @@ async function main() {
   const redacted = Object.values(stats.redactions).reduce((sum, count) => sum + count, 0);
   if (redacted > 0) parts.push(`${redacted} secrets redacted`);
   parts.push(formatMs(stats.timings.total));
-  console.error(`ctxman map: ${parts.join(' · ')}`);
+  console.error(`ctxman map: ${parts.join(' \u00b7 ')}`);
   if (options.output) console.error(`Map written to ${options.output}`);
 }