ctxman 3.2.7 → 3.2.8

package/bin/cli.js

@@ -810,8 +810,8 @@ function printHelp() {
   console.log('  who TARGET [options]     Find code & domain experts across git blame, history,');
   console.log('                           and CODEOWNERS (--repo DIR for multi-repo workspaces)');
   console.log('  search QUERY [path]      Ranked (BM25) search over methods and code chunks');
-  console.log('  count [path|-] [--model ID] [--api]');
-  console.log('                           Count tokens for a model (exact for Claude with --api)');
+  console.log('  count [path|-] [--model ID] [--repo DIR] [--api]');
+  console.log('                           Count tokens for a model or multi-repo workspace');
   console.log('  mcp [install|uninstall|config]');
   console.log('                           Start the MCP server or add it to an MCP client');
   console.log(

package/bin/cm-count.js

@@ -20,11 +20,12 @@ getLogger().level = 'warn';
 
 const HELP = `Usage: ctxman count [path | -] [options]
 
-Count the tokens of a project (or of text piped to stdin with "-") for a target model,
-and check them against the model's context window.
+Count the tokens of a project, multi-repository workspace, or text piped to stdin with "-"
+for a target model, and check them against the model's context window.
 
 Options:
   --model, -m ID     Target model (default: ${LLMDetector.getDefaultModelId()}; see ctxman --list-llms)
+  --repo DIR         Additional repository root to count in a workspace (repeatable)
   --api              Claude models: count exactly with Anthropic's count_tokens API.
                      Sends the (secret-redacted) text to Anthropic; needs ANTHROPIC_API_KEY
                      and the @anthropic-ai/sdk package. Counting is free and generates nothing.
@@ -39,26 +40,46 @@ their counts are approximate.
 Examples:
   ctxman count --model gpt-6.1-sol
   ctxman count --model claude-opus-5-5 --api
+  ctxman count ./api --repo ../shared --repo ../web --model claude-sonnet-5-5
   ctxman pack | ctxman count - --model claude-sonnet-5-5 --api`;
 
 function parseArgs(argv) {
-  const options = { top: 5 };
+  const options = { top: 5, repos: [] };
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
     if (arg === '--model' || arg === '-m') options.model = argv[++i];
-    else if (arg === '--api') options.api = true;
+    else if (arg.startsWith('--model=')) options.model = arg.slice('--model='.length);
+    else if (arg === '--repo') {
+      const repoDir = argv[++i];
+      if (!repoDir || repoDir.startsWith('-')) {
+        throw new Error('--repo needs a directory path');
+      }
+      options.repos.push(repoDir);
+    } else if (arg.startsWith('--repo=')) {
+      const repoDir = arg.slice('--repo='.length);
+      if (!repoDir) throw new Error('--repo needs a directory path');
+      options.repos.push(repoDir);
+    } else if (arg === '--api') options.api = true;
     else if (arg === '--json') options.json = true;
     else if (arg === '--top') options.top = Number.parseInt(argv[++i], 10);
+    else if (arg.startsWith('--top='))
+      options.top = Number.parseInt(arg.slice('--top='.length), 10);
     else if (arg === '--help' || arg === '-h') options.help = true;
     else if (arg === '-' || !arg.startsWith('-')) options.target = arg;
     else throw new Error(`Unknown option: ${arg}`);
   }
-  if (options.model === undefined && argv.includes('--model')) {
+  if (
+    (options.model === undefined || options.model === '') &&
+    argv.some((a) => a === '--model' || a === '-m' || a === '--model=')
+  ) {
     throw new Error('--model needs a model id');
   }
   if (!Number.isInteger(options.top) || options.top < 0) {
     throw new Error('--top needs a number of files');
   }
+  if (options.target === '-' && options.repos.length > 0) {
+    throw new Error('Cannot combine --repo with stdin ("-")');
+  }
   return options;
 }
 
@@ -89,8 +110,17 @@ function printResult(result, top) {
     print(`         For an exact count: ctxman count --model ${result.model} --api`);
   }
 
+  if (result.repos?.length > 1) {
+    print('\nRepositories:');
+    for (const repo of result.repos) {
+      print(
+        `  ${n(repo.tokens).padStart(9)}  ${repo.alias} (${n(repo.files)} file${repo.files === 1 ? '' : 's'}, ${repo.percentOfWindow.toFixed(1)}%)`
+      );
+    }
+  }
+
   const largest = result.largestFiles.slice(0, top);
-  if (largest.length > 1) {
+  if (largest.length > 1 || (result.repos?.length > 1 && largest.length > 0)) {
     const scale = result.method === 'anthropic-api' && result.ratio ? result.ratio : 1;
     print(`\nLargest files${scale !== 1 ? ' (≈, scaled to the API count)' : ''}:`);
     for (const file of largest) {
@@ -119,6 +149,14 @@ async function main() {
     process.exit(1);
   }
 
+  const repos = options.repos.map((r) => path.resolve(r));
+  for (const repoPath of repos) {
+    if (!fs.statSync(repoPath, { throwIfNoEntry: false })?.isDirectory()) {
+      console.error(`❌ Not a directory: ${repoPath}`);
+      process.exit(1);
+    }
+  }
+
   const model = options.model || LLMDetector.getDefaultModelId();
   if (options.api && LLMDetector.getProfile(model).vendor === 'Anthropic') {
     console.error('Sending the redacted text to the Anthropic API to count tokens...');
@@ -129,6 +167,7 @@ async function main() {
       model,
       api: options.api,
       text,
+      repos,
       onProgress: (done, total) => {
         if (total > 1) process.stderr.write(`\r  request ${done}/${total}`);
         if (total > 1 && done === total) process.stderr.write('\n');

package/index.d.ts

@@ -1765,6 +1765,7 @@ export function getSymbol(root: string, query: string, options?: GetSymbolOption
 export interface CountForModelOptions {
   model?: string;
   text?: string;
+  repos?: WorkspaceRepoInput[];
   api?: boolean;
   client?: unknown;
   onProgress?: (done: number, total: number) => void;
@@ -1785,6 +1786,14 @@ export interface CountForModelResult {
   percentOfWindow: number;
   requests?: number;
   ratio?: number | null;
+  repos?: Array<{
+    alias: string;
+    root: string;
+    files: number;
+    localTokens: number;
+    tokens: number;
+    percentOfWindow: number;
+  }>;
   largestFiles: Array<{ path: string; tokens: number }>;
 }
 

package/lib/api/mcp/server.js

@@ -25,7 +25,12 @@ import { countForModel } from '../../count/index.js';
 import { explainHistory } from '../../why/index.js';
 import { packContext, describePack, TOOL_DEFAULT_BUDGET } from '../../pack/index.js';
 import { focusContext, describeFocus, DEFAULT_FOCUS_DEPTH } from '../../focus/index.js';
-import { mapWorkspace, searchWorkspace, packWorkspace } from '../../workspace/index.js';
+import {
+  resolveWorkspaceRepos,
+  mapWorkspace,
+  searchWorkspace,
+  packWorkspace,
+} from '../../workspace/index.js';
 import {
   loadPolicy,
   guardExport,
@@ -118,7 +123,8 @@ class MCPServer {
         tools: [
           {
             name: 'analyze_codebase',
-            description: 'Analyze the codebase and return statistics and token counts',
+            description:
+              'Analyze the codebase (single-repo or multi-repo workspace) and return statistics and token counts',
             inputSchema: {
               type: 'object',
               properties: {
@@ -126,13 +132,20 @@ class MCPServer {
                   type: 'string',
                   description: 'Absolute path to the project root',
                 },
+                repos: {
+                  type: 'array',
+                  items: { type: 'string' },
+                  description:
+                    'Additional repository roots to analyze together in a multi-repository workspace',
+                },
               },
               required: ['path'],
             },
           },
           {
             name: 'generate_context',
-            description: 'Generate optimized context for LLMs from the codebase',
+            description:
+              'Generate optimized context for LLMs from the codebase (single-repo or multi-repo workspace)',
             inputSchema: {
               type: 'object',
               properties: {
@@ -149,13 +162,20 @@ class MCPServer {
                   type: 'number',
                   description: 'Maximum tokens for the context',
                 },
+                repos: {
+                  type: 'array',
+                  items: { type: 'string' },
+                  description:
+                    'Additional repository roots to include in multi-repository context generation',
+                },
               },
               required: ['path'],
             },
           },
           {
             name: 'git_diff',
-            description: 'Analyze git changes and return diff context',
+            description:
+              'Analyze git changes (single-repo or multi-repo workspace) and return diff context',
             inputSchema: {
               type: 'object',
               properties: {
@@ -164,6 +184,12 @@ class MCPServer {
                   type: 'string',
                   description: 'Branch to compare against (default: main)',
                 },
+                repos: {
+                  type: 'array',
+                  items: { type: 'string' },
+                  description:
+                    'Additional repository roots to include in multi-repository git diff',
+                },
               },
               required: ['path'],
             },
@@ -171,7 +197,7 @@ class MCPServer {
           {
             name: 'search_code',
             description:
-              'Search source lines by regular expression (default) or plain substring. "ranked" returns BM25-ranked methods/chunks; "semantic" runs vector embedding search projected onto chunks (with BM25 fallback); "hybrid" fuses BM25 and semantic embeddings via Reciprocal Rank Fusion (RRF).',
+              'Search source lines by regular expression (default) or plain substring (single-repo or multi-repo workspace). "ranked" returns BM25-ranked methods/chunks; "semantic" runs vector embedding search projected onto chunks (with BM25 fallback); "hybrid" fuses BM25 and semantic embeddings via Reciprocal Rank Fusion (RRF).',
             inputSchema: {
               type: 'object',
               properties: {
@@ -197,8 +223,7 @@ class MCPServer {
                 repos: {
                   type: 'array',
                   items: { type: 'string' },
-                  description:
-                    'ranked/hybrid: additional repository roots to search across under one shared token budget',
+                  description: 'Additional repository roots to search across in the workspace',
                 },
               },
               required: ['path', 'query'],
@@ -206,7 +231,8 @@ class MCPServer {
           },
           {
             name: 'list_methods',
-            description: 'List all methods/functions in a given file or project',
+            description:
+              'List all methods/functions in a given file, project, or multi-repository workspace',
             inputSchema: {
               type: 'object',
               properties: {
@@ -216,7 +242,14 @@ class MCPServer {
                 },
                 file: {
                   type: 'string',
-                  description: 'Optional: Relative path to a specific file within the project',
+                  description:
+                    'Optional: Relative path (or <alias>/<path>) to a specific file within the project',
+                },
+                repos: {
+                  type: 'array',
+                  items: { type: 'string' },
+                  description:
+                    'Additional repository roots to list methods across in a multi-repository workspace',
                 },
               },
               required: ['path'],
@@ -307,7 +340,7 @@ class MCPServer {
           {
             name: 'count_tokens',
             description:
-              "Token count of a project (or of a text) for a model, with the model's context window and whether it fits. Exact for OpenAI models; approximate for models with their own tokenizer (Claude, Gemini, ...). Nothing leaves the machine; for Claude's exact count run `ctxman count --model <id> --api`",
+              "Token count of a project or multi-repository workspace (or of a text) for a model, with the model's context window and whether it fits. Exact for OpenAI models; approximate for models with their own tokenizer (Claude, Gemini, ...). Nothing leaves the machine; for Claude's exact count run `ctxman count --model <id> --api`",
             inputSchema: {
               type: 'object',
               properties: {
@@ -324,6 +357,12 @@ class MCPServer {
                   type: 'number',
                   description: 'How many of the largest files to list (default 10)',
                 },
+                repos: {
+                  type: 'array',
+                  items: { type: 'string' },
+                  description:
+                    'Additional repository roots to count across in a multi-repository workspace (ignored when text is given)',
+                },
               },
             },
           },
@@ -813,6 +852,28 @@ class MCPServer {
             // Update resource provider project path
             this.resourceProvider.projectPath = projectPath;
 
+            if (args.repos?.length > 0) {
+              const resolvedRepos = resolveWorkspaceRepos([projectPath, ...args.repos]);
+              const allFiles = [];
+              for (const repo of resolvedRepos) {
+                const scanner = new Scanner(repo.root, { policy: repo.policy });
+                for (const file of scanner.scan()) {
+                  const relPosix = `${repo.alias}/${file.relativePath.split(path.sep).join('/')}`;
+                  allFiles.push({
+                    ...file,
+                    relativePath: relPosix,
+                  });
+                }
+              }
+              const analysis = await this.analyzer.analyze(allFiles);
+              analysis.repos = resolvedRepos.map((r) => ({ alias: r.alias, root: r.root }));
+              const analysisId = Date.now().toString();
+              this.resourceProvider.cacheAnalysis(analysisId, analysis);
+              return {
+                content: [{ type: 'text', text: JSON.stringify(analysis, null, 2) }],
+              };
+            }
+
             const scanner = new Scanner(projectPath);
             const files = scanner.scan();
             const analysis = await this.analyzer.analyze(files);
@@ -836,20 +897,57 @@ class MCPServer {
             // Update resource provider project path
             this.resourceProvider.projectPath = projectPath;
 
-            const scanner = new Scanner(projectPath);
-            const files = scanner.scan();
-            const analysis = await this.analyzer.analyze(files);
-
-            // Configure ContextBuilder based on args
             const builderOptions = {
               targetTokens: args.maxTokens,
               useCase: args.template || 'custom',
             };
             const contextBuilder = new ContextBuilder(builderOptions);
+            const templateName = args.template || 'custom';
+
+            if (args.repos?.length > 0) {
+              const resolvedRepos = resolveWorkspaceRepos([projectPath, ...args.repos]);
+              const allFiles = [];
+              for (const repo of resolvedRepos) {
+                const scanner = new Scanner(repo.root, { policy: repo.policy });
+                for (const file of scanner.scan()) {
+                  const relPosix = `${repo.alias}/${file.relativePath.split(path.sep).join('/')}`;
+                  allFiles.push({
+                    ...file,
+                    relativePath: relPosix,
+                  });
+                }
+              }
+              const analysis = await this.analyzer.analyze(allFiles);
+              const context = contextBuilder.build(analysis);
+              context.repos = resolvedRepos.map((r) => ({ alias: r.alias, root: r.root }));
+              const contextText = JSON.stringify(context, null, 2);
+              const exportedFiles = Object.values(context.files || {}).flat();
+              for (const repo of resolvedRepos) {
+                const prefix = `${repo.alias}/`;
+                const repoFiles = exportedFiles
+                  .filter((f) => typeof f.path === 'string' && f.path.startsWith(prefix))
+                  .map((f) => ({ ...f, path: f.path.slice(prefix.length) }));
+                guardExport(repo.policy, {
+                  command: 'mcp generate_context',
+                  root: repo.root,
+                  destination: 'mcp',
+                  format: 'json',
+                  files: repoFiles,
+                  text: contextText,
+                });
+              }
+              this.resourceProvider.cacheContext(templateName, contextText);
+              return {
+                content: [{ type: 'text', text: contextText }],
+              };
+            }
+
+            const scanner = new Scanner(projectPath);
+            const files = scanner.scan();
+            const analysis = await this.analyzer.analyze(files);
             const context = contextBuilder.build(analysis);
 
             // Cache context as a resource
-            const templateName = args.template || 'custom';
             const contextText = JSON.stringify(context, null, 2);
             // Export policy: throws PolicyViolationError (an isError result) and logs the export
             guardExport(loadPolicy(projectPath), {
@@ -873,7 +971,6 @@ class MCPServer {
           }
           case 'git_diff': {
             const projectPath = args.path;
-            const gitClient = new GitClient(projectPath);
             const branch = args.branch || 'main';
 
             if (!isValidGitRef(branch)) {
@@ -885,6 +982,47 @@ class MCPServer {
               };
             }
 
+            if (args.repos?.length > 0) {
+              const resolvedRepos = resolveWorkspaceRepos([projectPath, ...args.repos]);
+              const diffs = [];
+              const errors = [];
+              for (const repo of resolvedRepos) {
+                try {
+                  const gitClient = new GitClient(repo.root);
+                  const rawDiff = gitClient.exec([
+                    'diff',
+                    branch,
+                    '--',
+                    ...(this.root ? ['.'] : []),
+                  ]);
+                  if (rawDiff && rawDiff.trim()) {
+                    const prefixed = rawDiff
+                      .replace(
+                        /^diff --git a\/(.+) b\/(.+)$/gm,
+                        `diff --git a/${repo.alias}/$1 b/${repo.alias}/$2`
+                      )
+                      .replace(/^--- a\/(.+)$/gm, `--- a/${repo.alias}/$1`)
+                      .replace(/^\+\+\+ b\/(.+)$/gm, `+++ b/${repo.alias}/$1`);
+                    diffs.push(prefixed.trimEnd());
+                  }
+                } catch (e) {
+                  errors.push(`${repo.alias}: ${e.message}`);
+                }
+              }
+              if (errors.length === resolvedRepos.length) {
+                return {
+                  content: [{ type: 'text', text: `Error executing git diff: ${errors[0]}` }],
+                  isError: true,
+                };
+              }
+              const notes = errors.map((err) => `# Note: ${err}`).join('\n');
+              const combined = [diffs.join('\n'), notes].filter(Boolean).join('\n\n');
+              return {
+                content: [{ type: 'text', text: combined || 'No changes detected.' }],
+              };
+            }
+
+            const gitClient = new GitClient(projectPath);
             let diff;
             try {
               // With a root, keep the diff to that directory even if the repository is larger
@@ -942,6 +1080,37 @@ class MCPServer {
                 };
               }
             }
+
+            if (args.repos?.length > 0) {
+              const resolvedRepos = resolveWorkspaceRepos([projectPath, ...args.repos]);
+              const results = [];
+              for (const repo of resolvedRepos) {
+                const scanner = new Scanner(repo.root, { policy: repo.policy });
+                for (const file of scanner.scan()) {
+                  try {
+                    const content = fs.readFileSync(file.path, 'utf-8');
+                    const lines = content.split('\n');
+                    const relPosix = `${repo.alias}/${file.relativePath.split(path.sep).join('/')}`;
+                    lines.forEach((line, index) => {
+                      const match = pattern ? pattern.test(line) : line.includes(query);
+                      if (match) {
+                        results.push({
+                          file: relPosix,
+                          line: index + 1,
+                          content: line.trim(),
+                        });
+                      }
+                    });
+                  } catch (_e) {
+                    // Skip read errors
+                  }
+                }
+              }
+              return {
+                content: [{ type: 'text', text: JSON.stringify(results, null, 2) }],
+              };
+            }
+
             const scanner = new Scanner(projectPath);
             const files = scanner.scan();
             const results = [];
@@ -979,6 +1148,48 @@ class MCPServer {
               file = path.basename(projectPath);
               projectPath = path.dirname(projectPath);
             }
+
+            if (args.repos?.length > 0) {
+              const resolvedRepos = resolveWorkspaceRepos([projectPath, ...args.repos]);
+              const targetPosix = file ? file.split(path.sep).join('/').replace(/^\.\//, '') : null;
+              const allFiles = [];
+              for (const repo of resolvedRepos) {
+                const scanner = new Scanner(repo.root, { policy: repo.policy });
+                for (const f of scanner.scan()) {
+                  const barePosix = f.relativePath.split(path.sep).join('/');
+                  const relPosix = `${repo.alias}/${barePosix}`;
+                  if (!targetPosix || relPosix === targetPosix || barePosix === targetPosix) {
+                    allFiles.push({
+                      ...f,
+                      relativePath: relPosix,
+                    });
+                  }
+                }
+              }
+              if (targetPosix && allFiles.length === 0) {
+                return {
+                  content: [{ type: 'text', text: `File not found in project: ${file}` }],
+                  isError: true,
+                };
+              }
+              const methodAnalyzer = new Analyzer({ methodLevel: true, cache: true });
+              const analysis = await methodAnalyzer.analyze(allFiles);
+              const methods = [];
+              if (analysis.files) {
+                for (const analyzedFile of analysis.files) {
+                  if (analyzedFile.methods && analyzedFile.methods.length > 0) {
+                    methods.push({
+                      file: analyzedFile.relativePath,
+                      methods: analyzedFile.methods,
+                    });
+                  }
+                }
+              }
+              return {
+                content: [{ type: 'text', text: JSON.stringify(methods, null, 2) }],
+              };
+            }
+
             const scanner = new Scanner(projectPath);
             // Optional `file`: one project-relative file instead of the whole project
             const target = file ? path.normalize(file) : null;
@@ -1060,6 +1271,7 @@ class MCPServer {
             const { largestFiles, ...summary } = await countForModel(args.path, {
               model: args.model,
               text: args.text,
+              repos: args.repos,
             });
             const top = Number.isInteger(args.top) && args.top >= 0 ? args.top : 10;
             const result = { ...summary, largestFiles: largestFiles.slice(0, top) };

package/lib/count/index.js

@@ -1,40 +1,73 @@
 /**
  * Token count for a target model
- * Counts a project (or a piped text) with the target model's tokenizer where one is
- * available offline (tiktoken for OpenAI models), and, on request, exactly through
- * Anthropic's count_tokens API for Claude models.
+ * Counts a project, multi-repository workspace, or piped text with the target model's
+ * tokenizer where one is available offline (tiktoken for OpenAI models), and, on request,
+ * exactly through Anthropic's count_tokens API for Claude models.
  */
 
 import fs from 'fs';
+import path from 'path';
 import Scanner from '../core/Scanner.js';
 import TokenUtils from '../utils/token-utils.js';
 import { LLMDetector } from '../utils/llm-detector.js';
 import { ClaudeTokenCounter } from '../utils/claude-token-counter.js';
 import { redactSecrets } from '../utils/secret-redactor.js';
+import { resolveWorkspaceRepos } from '../workspace/index.js';
 
 /**
- * Read the documents to count
+ * Read the documents to count from a single project or multi-repository workspace
  * @param {string} root - Project root (ignored when `text` is given)
  * @param {string} [text] - A single piped text instead of the project files
- * @returns {{path: string, content: string}[]}
+ * @param {Array<string|{root: string, alias?: string}>} [repos] - Additional repository roots
+ * @returns {{documents: {path: string, content: string, repo?: string}[], resolvedRepos: {root: string, alias: string}[] | null}}
  */
-function readDocuments(root, text) {
-  if (text !== undefined) return [{ path: '<stdin>', content: text }];
-  return new Scanner(root).scan().flatMap((file) => {
+function readDocuments(root, text, repos) {
+  if (text !== undefined) {
+    return {
+      documents: [{ path: '<stdin>', content: text }],
+      resolvedRepos: null,
+    };
+  }
+
+  const extraRepos = Array.isArray(repos) ? repos.filter(Boolean) : [];
+  if (extraRepos.length > 0) {
+    const resolvedRepos = resolveWorkspaceRepos([root, ...extraRepos]);
+    const documents = [];
+    for (const repo of resolvedRepos) {
+      const scanned = new Scanner(repo.root, { policy: repo.policy }).scan();
+      for (const file of scanned) {
+        try {
+          const relPosix = file.relativePath.split(path.sep).join('/');
+          documents.push({
+            path: `${repo.alias}/${relPosix}`,
+            repo: repo.alias,
+            content: fs.readFileSync(file.path, 'utf8'),
+          });
+        } catch (_error) {
+          // Skip unreadable files
+        }
+      }
+    }
+    return { documents, resolvedRepos };
+  }
+
+  const documents = new Scanner(root).scan().flatMap((file) => {
     try {
       return [{ path: file.relativePath, content: fs.readFileSync(file.path, 'utf8') }];
     } catch (_error) {
       return [];
     }
   });
+  return { documents, resolvedRepos: null };
 }
 
 /**
- * Count tokens for a target model
+ * Count tokens for a target model across a project, multi-repo workspace, or piped text
  * @param {string} root - Project root
  * @param {object} [options]
  * @param {string} [options.model] - Target model id or alias (default: DEFAULT_TARGET_MODEL)
  * @param {string} [options.text] - Count this text instead of the project
+ * @param {Array<string|{root: string, alias?: string}>} [options.repos] - Additional workspace repository roots
  * @param {boolean} [options.api=false] - Count exactly with the Anthropic API (Claude only)
  * @param {object} [options.client] - Anthropic client stand-in (tests)
  * @param {(done: number, total: number) => void} [options.onProgress]
@@ -45,12 +78,13 @@ export async function countForModel(root, options = {}) {
   const profile = LLMDetector.getProfile(requested);
   const modelId = profile.id || requested;
   const encoding = TokenUtils.encodingFor(modelId);
-  const documents = readDocuments(root, options.text);
+  const { documents, resolvedRepos } = readDocuments(root, options.text, options.repos);
 
   const files = documents
     .map((doc) => ({
       path: doc.path,
       tokens: TokenUtils.calculate(doc.content, doc.path, encoding),
+      ...(doc.repo ? { repo: doc.repo } : {}),
     }))
     .sort((a, b) => b.tokens - a.tokens);
   const localTokens = files.reduce((sum, file) => sum + file.tokens, 0);
@@ -67,7 +101,7 @@ export async function countForModel(root, options = {}) {
     // tiktoken matches OpenAI models whose encoding is published; others are approximations
     exact: TokenUtils.isExact() && profile.tokenizer?.exact === true,
     contextWindow: profile.contextWindow,
-    largestFiles: files,
+    largestFiles: files.map(({ path: filePath, tokens }) => ({ path: filePath, tokens })),
   };
 
   if (options.api) {
@@ -89,11 +123,37 @@ export async function countForModel(root, options = {}) {
     result.method = 'anthropic-api';
     result.exact = true;
     result.requests = requests;
-    result.ratio = localTokens > 0 ? total / localTokens : null;
+    result.ratio = localTokens > 0 ? total / localTokens : 1;
+    // The API counts batches, not single files; scale each file's local count by the
+    // observed ratio so the per-file breakdown matches the model too
+    result.largestFiles = files.map(({ path: filePath, tokens }) => ({
+      path: filePath,
+      tokens: Math.round(tokens * result.ratio),
+    }));
+  }
+
+  const window = result.contextWindow || 0;
+  result.fits = window > 0 ? result.tokens <= window : true;
+  result.percentOfWindow = window > 0 ? (result.tokens / window) * 100 : 0;
+
+  if (resolvedRepos) {
+    const ratio = result.method === 'anthropic-api' && result.ratio ? result.ratio : 1;
+    result.repos = resolvedRepos.map((repo) => {
+      const repoFiles = files.filter((f) => f.repo === repo.alias);
+      const repoLocalTokens = repoFiles.reduce((sum, f) => sum + f.tokens, 0);
+      const repoTokens =
+        result.method === 'anthropic-api' ? Math.round(repoLocalTokens * ratio) : repoLocalTokens;
+      return {
+        alias: repo.alias,
+        root: repo.root,
+        files: repoFiles.length,
+        localTokens: repoLocalTokens,
+        tokens: repoTokens,
+        percentOfWindow: window > 0 ? (repoTokens / window) * 100 : 0,
+      };
+    });
   }
 
-  result.fits = result.tokens <= result.contextWindow;
-  result.percentOfWindow = (result.tokens / result.contextWindow) * 100;
   return result;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctxman",
-  "version": "3.2.7",
+  "version": "3.2.8",
   "description": "AI Development Platform with plugin architecture, Git integration, REST API, watch mode, LLM optimization, and support for 14+ languages. Features include TOON format (40-50% token reduction), real-time analysis, and comprehensive context generation.",
   "type": "module",
   "main": "index.js",