improvements for python

Author: Евгений Балякин

src/core/context.ts

@@ -18,7 +18,7 @@ export interface ContextOptions {
   budget?: number;
   includeTests?: boolean;
   changedOnly?: boolean;
-  mode?: 'full' | 'architecture' | 'overview' | 'edit_prep' | 'composition';
+  mode?: 'full' | 'architecture' | 'overview' | 'edit_prep' | 'composition' | 'test_impact';
   productionOnly?: boolean;
   testsOnly?: boolean;
   includeMocks?: boolean;
@@ -108,14 +108,16 @@ export async function buildContext(root: string, options: ContextOptions) {
   const items = [] as Array<{ type: 'skeleton' | 'symbol_body'; path: string; score: number; reason: string; content: string; symbolId?: string }>;
   let usedTokens = 0;
   const testRelations = inferTestRelations(fileRecords, graph.edges).slice(0, 30);
-  if (options.mode === 'architecture' || options.mode === 'overview' || options.mode === 'edit_prep' || options.mode === 'composition') {
+  if (options.mode === 'architecture' || options.mode === 'overview' || options.mode === 'edit_prep' || options.mode === 'composition' || options.mode === 'test_impact') {
     const architecture = buildArchitectureSummary(fileRecords, graph.edges, testRelations, changedFiles);
     const content = options.mode === 'overview'
       ? renderOverviewSummary(architecture)
       : options.mode === 'edit_prep'
         ? renderEditPrepSummary(architecture, options.goal)
         : options.mode === 'composition'
           ? renderCompositionSummary(architecture, budget)
+          : options.mode === 'test_impact'
+            ? renderTestImpactSummary(architecture, options.goal)
           : renderArchitectureSummary(architecture, budget);
     const omitted = omittedFiles.slice(0, 20);
     const data = { schemaVersion: SCHEMA_VERSION, goal: options.goal, mode: options.mode, budget, usedTokens: estimateTokens(content), items: [{ type: `${options.mode}_summary` as const, path: options.path ?? '.', score: 1, reason: `compact ${options.mode} summary`, content }], omitted, nextReads: ranked.slice(0, 10).map((item) => ({ command: 'skeleton', path: item.path, symbolId: item.symbolId })), architecture, testRelations, warnings, truncated: omitted.length > 0 || estimateTokens(renderArchitectureSummary(architecture)) > budget, tokenEstimate: estimateTokens(content) };
@@ -247,7 +249,10 @@ function renderArchitectureSummary(summary: ReturnType<typeof buildArchitectureS
   if (summary.dependencies.length) sections.push(`App dependency graph:\n${summary.dependencies.map((item) => {
     const writes = item.writes.length ? ` created: ${item.writes.map((usage) => `${usage.file}:${usage.line}${usage.value ? ` = ${usage.value}` : ''}`).join(', ')}` : '';
     const reads = item.reads.length ? ` read: ${item.reads.slice(0, 6).map((usage) => `${usage.file}:${usage.line}`).join(', ')}` : '';
-    return `  app["${item.key}"]${writes}${reads}`;
+    const starts = item.starts.length ? ` start: ${item.starts.map((usage) => `${usage.file}:${usage.line}`).join(', ')}` : '';
+    const stops = item.stops.length ? ` stop: ${item.stops.map((usage) => `${usage.file}:${usage.line}`).join(', ')}` : '';
+    const risk = item.starts.length && !item.stops.length ? ' [risk: started but no stop found]' : '';
+    return `  app["${item.key}"]${writes}${reads}${starts}${stops}${risk}`;
   }).join('\n')}`);
   if (summary.tables.length) sections.push(`SQLAlchemy tables:\n${summary.tables.map((item) => `  ${item.name} (${item.file}:${item.line})`).join('\n')}`);
   if (summary.changed.length) sections.push(`Changed files impact:\n${summary.changed.map((item) => `  ${item.path}${item.tests.length ? ` -> tests: ${item.tests.join(', ')}` : ''}`).join('\n')}`);
@@ -297,13 +302,31 @@ function renderCompositionSummary(summary: ReturnType<typeof buildArchitectureSu
   if (summary.dependencies.length) sections.push(`App dependencies:\n${summary.dependencies.map((item) => {
     const writes = item.writes.length ? `created ${item.writes.map((usage) => `${usage.file}:${usage.line}${usage.value ? ` = ${usage.value}` : ''}`).join(', ')}` : 'no creator found';
     const reads = item.reads.length ? `; read ${item.reads.slice(0, 5).map((usage) => `${usage.file}:${usage.line}`).join(', ')}` : '';
-    return `  app["${item.key}"] ${writes}${reads}`;
+    const lifecycle = `${item.starts.length ? `; start ${item.starts.map((usage) => `${usage.file}:${usage.line}`).join(', ')}` : ''}${item.stops.length ? `; stop ${item.stops.map((usage) => `${usage.file}:${usage.line}`).join(', ')}` : ''}${item.starts.length && !item.stops.length ? '; risk: started but no stop found' : ''}`;
+    return `  app["${item.key}"] ${writes}${reads}${lifecycle}`;
   }).join('\n')}`);
   if (summary.layers.integrations.length) sections.push(`External integrations:\n${summary.layers.integrations.slice(0, 15).map((file) => `  ${file}`).join('\n')}`);
   if (summary.layers.background.length) sections.push(`Background jobs/consumers:\n${summary.layers.background.slice(0, 15).map((file) => `  ${file}`).join('\n')}`);
   return fitSections(sections, budget);
 }
 
+function renderTestImpactSummary(summary: ReturnType<typeof buildArchitectureSummary>, goal: string): string {
+  const query = goal.toLowerCase().split(/[^a-z0-9_./]+/).filter((term) => term.length > 2);
+  const scored = summary.testRelations.map((relation) => {
+    const haystack = `${relation.source} ${relation.test}`.toLowerCase();
+    const score = query.reduce((sum, term) => sum + (haystack.includes(term) ? 1 : 0), 0) + (relation.reason === 'import' ? 2 : relation.reason === 'symbol_mention' ? 1.5 : 1);
+    return { ...relation, score };
+  }).filter((relation) => relation.score > 0).sort((a, b) => b.score - a.score || a.test.localeCompare(b.test)).slice(0, 12);
+  const sections = [`Test impact for: ${goal}`];
+  if (scored.length) sections.push(`Pytest candidates:\n${scored.map((item) => `  ${item.test} (covers ${item.source}; ${item.reason})`).join('\n')}`);
+  const fixtureHints = Array.from(new Set(scored.flatMap((item) => [item.test, item.source]).filter((file) => /fixture|mock|fake|conftest/i.test(file))));
+  const external = Array.from(new Set(scored.flatMap((item) => [item.test, item.source]).join(' ').match(/redis|rabbit|postgres|mongo|kafka/gi) ?? [])).map((item) => item.toLowerCase());
+  if (fixtureHints.length) sections.push(`Fixture/mock hints:\n${fixtureHints.map((item) => `  ${item}`).join('\n')}`);
+  if (external.length) sections.push(`External services hinted by paths: ${external.join(', ')}`);
+  if (!scored.length) sections.push('No direct test relation found. Use codebone_symbols for the changed symbol, then run nearest API/task tests by path proximity.');
+  return sections.join('\n\n');
+}
+
 function summarizeLayers(fileRecords: Array<{ path: string }>) {
   const layers: Record<string, string[]> = { entrypoints: [], api: [], services: [], persistence: [], background: [], integrations: [], tests: [] };
   for (const record of fileRecords) {
@@ -330,12 +353,14 @@ function fitSections(sections: string[], budget: number): string {
 }
 
 function buildAppDependencyGraph(fileRecords: Array<{ path: string; symbols: ReturnType<typeof flattenSymbols> }>) {
-  const byKey = new Map<string, { key: string; writes: Array<{ file: string; line: number; value?: string }>; reads: Array<{ file: string; line: number }> }>();
+  const byKey = new Map<string, { key: string; writes: Array<{ file: string; line: number; value?: string }>; reads: Array<{ file: string; line: number }>; starts: Array<{ file: string; line: number }>; stops: Array<{ file: string; line: number }> }>();
   for (const record of fileRecords) {
     for (const symbol of record.symbols.filter((item) => item.kind === 'dependency')) {
-      const entry = byKey.get(symbol.name) ?? { key: symbol.name, writes: [], reads: [] };
+      const entry = byKey.get(symbol.name) ?? { key: symbol.name, writes: [], reads: [], starts: [], stops: [] };
       const usage = { file: record.path, line: symbol.startLine };
       if (/\b(?:app|request\.app)\[['"][^'"]+['"]\]\s*=/.test(symbol.signature)) entry.writes.push({ ...usage, value: symbol.signature.split('=').slice(1).join('=').trim().slice(0, 80) });
+      else if (/\[['"][^'"]+['"]\]\.(?:start|startup)\s*\(/.test(symbol.signature)) entry.starts.push(usage);
+      else if (/\[['"][^'"]+['"]\]\.(?:stop|close|shutdown|cleanup)\s*\(/.test(symbol.signature)) entry.stops.push(usage);
       else entry.reads.push(usage);
       byKey.set(symbol.name, entry);
     }

src/core/directory-skeleton.ts

@@ -6,13 +6,13 @@ import { estimateTokens } from './budget.js';
 
 const execFileAsync = promisify(execFile);
 
-export async function skeletonDirectory(root: string, inputPath: string, options: { maxFiles?: number; budget?: number; publicOnly?: boolean; publicApiOnly?: boolean; symbolsOnly?: boolean; includePrivate?: boolean; includeRoutes?: boolean; include?: string[]; exclude?: string[]; sort?: string; changedOnly?: boolean; respectAiIgnore?: boolean; mode?: 'full' | 'summary' | 'public_api' } = {}) {
+export async function skeletonDirectory(root: string, inputPath: string, options: { maxFiles?: number; budget?: number; publicOnly?: boolean; publicApiOnly?: boolean; symbolsOnly?: boolean; includePrivate?: boolean; includeRoutes?: boolean; detail?: 'rpc_api' | 'lifecycle' | 'app_dependencies' | 'public_methods'; include?: string[]; exclude?: string[]; sort?: string; changedOnly?: boolean; respectAiIgnore?: boolean; mode?: 'full' | 'summary' | 'public_api' } = {}) {
   const files = await sortFiles(root, await walkSourceFiles(root, inputPath, { maxFiles: options.maxFiles ?? 100, include: options.include, exclude: options.exclude, respectAiIgnore: options.respectAiIgnore }), options.sort ?? 'path', Boolean(options.changedOnly));
   const skeletons = [];
   let used = 0;
   let truncated = false;
   for (const file of files) {
-    const skeleton = await skeletonPath(root, file.relativePath, { publicOnly: options.publicOnly, publicApiOnly: options.publicApiOnly || options.mode === 'public_api', symbolsOnly: options.symbolsOnly, includePrivate: options.includePrivate, includeRoutes: options.includeRoutes, noImports: options.mode === 'public_api', budget: options.budget });
+    const skeleton = await skeletonPath(root, file.relativePath, { publicOnly: options.publicOnly, publicApiOnly: options.publicApiOnly || options.mode === 'public_api', symbolsOnly: options.symbolsOnly, includePrivate: options.includePrivate, includeRoutes: options.includeRoutes, detail: options.detail, noImports: options.mode === 'public_api', budget: options.budget });
     const cost = skeleton.tokenEstimate;
     if (options.budget && skeletons.length > 0 && used + cost > options.budget) {
       truncated = true;

src/core/skeleton.ts

@@ -33,6 +33,7 @@ interface ExtractOptions {
   symbolsOnly?: boolean;
   includePrivate?: boolean;
   includeRoutes?: boolean;
+  detail?: 'rpc_api' | 'lifecycle' | 'app_dependencies' | 'public_methods';
   budget?: number;
 }
 
@@ -551,6 +552,10 @@ function filterPublicApi(symbols: CodeSymbol[], publicApiOnly: boolean): CodeSym
 
 function filterDetailLevel(symbols: CodeSymbol[], options: ExtractOptions): CodeSymbol[] {
   return symbols.filter((symbol) => {
+    if (options.detail === 'rpc_api') return symbol.kind === 'route' || (['function', 'method'].includes(symbol.kind) && symbol.name.startsWith('rpc_'));
+    if (options.detail === 'lifecycle') return ['function', 'method'].includes(symbol.kind) && /startup|shutdown|cleanup|setup|init|destroy|create_app|make_app|start|stop/i.test(symbol.name);
+    if (options.detail === 'app_dependencies') return symbol.kind === 'dependency';
+    if (options.detail === 'public_methods') return ['class', 'function', 'method'].includes(symbol.kind) && !symbol.name.startsWith('_');
     if (options.symbolsOnly && ['import', 'variable', 'constant', 'property'].includes(symbol.kind)) return false;
     if (options.includeRoutes === false && symbol.kind === 'route') return false;
     if (options.includePrivate === false && symbol.name.startsWith('_') && !symbol.name.startsWith('rpc_')) return false;

src/index.ts

@@ -54,10 +54,12 @@ program.command('skeleton')
     const stat = await fs.stat(absolutePath);
     if (stat.isDirectory()) {
       const mode = options.mode === 'summary' || options.mode === 'public_api' ? options.mode : 'full';
-      const data = await skeletonDirectory(root, inputPath, { publicOnly: Boolean(options.publicOnly), publicApiOnly: mode === 'public_api', symbolsOnly: Boolean(options.symbolsOnly), includePrivate: Boolean(options.includePrivate), includeRoutes: options.includeRoutes !== false, maxFiles: Number(options.maxFiles), budget: globals.budget ? Number(globals.budget) : 12000, include: options.include, exclude: options.exclude, sort: options.sort, changedOnly: Boolean(options.changed), respectAiIgnore: options.respectAiIgnore, mode });
+      const detail = ['rpc_api', 'lifecycle', 'app_dependencies', 'public_methods'].includes(options.mode) ? options.mode : undefined;
+      const data = await skeletonDirectory(root, inputPath, { publicOnly: Boolean(options.publicOnly), publicApiOnly: mode === 'public_api', symbolsOnly: Boolean(options.symbolsOnly), includePrivate: Boolean(options.includePrivate), includeRoutes: options.includeRoutes !== false, detail, maxFiles: Number(options.maxFiles), budget: globals.budget ? Number(globals.budget) : 12000, include: options.include, exclude: options.exclude, sort: options.sort, changedOnly: Boolean(options.changed), respectAiIgnore: options.respectAiIgnore, mode });
       printResult(format, renderDirectorySkeleton(data), envelope(root, { command: 'skeleton', path: inputPath }, data, startedAt));
     } else {
-      const data = await skeletonPath(root, inputPath, { publicOnly: Boolean(options.publicOnly), publicApiOnly: options.mode === 'public_api', symbolsOnly: Boolean(options.symbolsOnly), includePrivate: Boolean(options.includePrivate), includeRoutes: options.includeRoutes !== false, noImports: Boolean(options.noImports) || options.mode === 'public_api', budget: globals.budget ? Number(globals.budget) : undefined });
+      const detail = ['rpc_api', 'lifecycle', 'app_dependencies', 'public_methods'].includes(options.mode) ? options.mode : undefined;
+      const data = await skeletonPath(root, inputPath, { publicOnly: Boolean(options.publicOnly), publicApiOnly: options.mode === 'public_api', symbolsOnly: Boolean(options.symbolsOnly), includePrivate: Boolean(options.includePrivate), includeRoutes: options.includeRoutes !== false, detail, noImports: Boolean(options.noImports) || options.mode === 'public_api', budget: globals.budget ? Number(globals.budget) : undefined });
       printResult(format, renderSkeleton(data), envelope(root, { command: 'skeleton', path: inputPath }, data, startedAt));
     }
   }));
@@ -101,7 +103,7 @@ program.command('context')
   .option('--include-config', 'include config files')
   .option('--include-migrations', 'include migration files')
   .action(async (options) => run('context', async (root, format, startedAt) => {
-    const mode = ['architecture', 'overview', 'edit_prep', 'composition'].includes(options.mode) ? options.mode : 'full';
+    const mode = ['architecture', 'overview', 'edit_prep', 'composition', 'test_impact'].includes(options.mode) ? options.mode : 'full';
     const data = await buildContext(root, { goal: options.goal, path: options.path, budget: Number(options.budget), includeTests: options.includeTests, changedOnly: options.changedOnly, mode, productionOnly: Boolean(options.productionOnly), testsOnly: Boolean(options.testsOnly), includeMocks: Boolean(options.includeMocks), includeConfig: Boolean(options.includeConfig), includeMigrations: Boolean(options.includeMigrations) });
     printResult(format, renderContext(data), envelope(root, { command: 'context', goal: options.goal }, data, startedAt));
   }));

src/mcp-server.ts

@@ -106,12 +106,13 @@ async function callTool(projectRoot: string, name: string, args: Record<string,
     const target = String(args.path);
     const stat = await fs.stat(resolveInsideRoot(projectRoot, target));
     const mode = args.mode === 'summary' || args.mode === 'public_api' ? args.mode : 'full';
-    if (stat.isDirectory()) return skeletonDirectory(projectRoot, target, { publicOnly: Boolean(args.publicOnly), publicApiOnly: mode === 'public_api', symbolsOnly: Boolean(args.symbolsOnly), includePrivate: Boolean(args.includePrivate), includeRoutes: args.includeRoutes !== false, maxFiles: Number(args.maxFiles ?? 50), budget: Number(args.budget ?? 12000), changedOnly: Boolean(args.changedOnly), mode });
-    return skeletonPath(projectRoot, target, { publicOnly: Boolean(args.publicOnly), publicApiOnly: mode === 'public_api', symbolsOnly: Boolean(args.symbolsOnly), includePrivate: Boolean(args.includePrivate), includeRoutes: args.includeRoutes !== false, noImports: Boolean(args.noImports) || args.includeImports === false || mode === 'public_api', budget: Number(args.budget ?? 12000) });
+    const detail = ['rpc_api', 'lifecycle', 'app_dependencies', 'public_methods'].includes(String(args.mode)) ? String(args.mode) as 'rpc_api' | 'lifecycle' | 'app_dependencies' | 'public_methods' : undefined;
+    if (stat.isDirectory()) return skeletonDirectory(projectRoot, target, { publicOnly: Boolean(args.publicOnly), publicApiOnly: mode === 'public_api', symbolsOnly: Boolean(args.symbolsOnly), includePrivate: Boolean(args.includePrivate), includeRoutes: args.includeRoutes !== false, detail, maxFiles: Number(args.maxFiles ?? 50), budget: Number(args.budget ?? 12000), changedOnly: Boolean(args.changedOnly), mode });
+    return skeletonPath(projectRoot, target, { publicOnly: Boolean(args.publicOnly), publicApiOnly: mode === 'public_api', symbolsOnly: Boolean(args.symbolsOnly), includePrivate: Boolean(args.includePrivate), includeRoutes: args.includeRoutes !== false, detail, noImports: Boolean(args.noImports) || args.includeImports === false || mode === 'public_api', budget: Number(args.budget ?? 12000) });
   }
   if (name === 'codebone_symbols') return findSymbols(projectRoot, String(args.path ?? '.'), { query: String(args.query), kind: String(args.kind ?? 'all') as never, exact: args.exact === undefined ? undefined : Boolean(args.exact), fuzzy: Boolean(args.fuzzy), limit: Number(args.limit ?? 100), includeImports: args.includeImports !== false });
   if (name === 'codebone_read') return readCode(projectRoot, String(args.path), { symbolId: args.symbolId as string | undefined, symbol: args.symbol as string | undefined, lines: args.lines as string | undefined, context: Number(args.context ?? 0), maxBytes: Number(args.maxBytes ?? 65536) });
-  if (name === 'codebone_context') return buildContext(projectRoot, { goal: String(args.goal), path: String(args.path ?? '.'), budget: Number(args.budget ?? 8000), includeTests: args.includeTests !== false, changedOnly: Boolean(args.changedOnly), mode: ['architecture', 'overview', 'edit_prep', 'composition'].includes(String(args.mode)) ? String(args.mode) as 'architecture' | 'overview' | 'edit_prep' | 'composition' : 'full', productionOnly: Boolean(args.productionOnly), testsOnly: Boolean(args.testsOnly), includeMocks: Boolean(args.includeMocks), includeConfig: Boolean(args.includeConfig), includeMigrations: Boolean(args.includeMigrations) });
+  if (name === 'codebone_context') return buildContext(projectRoot, { goal: String(args.goal), path: String(args.path ?? '.'), budget: Number(args.budget ?? 8000), includeTests: args.includeTests !== false, changedOnly: Boolean(args.changedOnly), mode: ['architecture', 'overview', 'edit_prep', 'composition', 'test_impact'].includes(String(args.mode)) ? String(args.mode) as 'architecture' | 'overview' | 'edit_prep' | 'composition' | 'test_impact' : 'full', productionOnly: Boolean(args.productionOnly), testsOnly: Boolean(args.testsOnly), includeMocks: Boolean(args.includeMocks), includeConfig: Boolean(args.includeConfig), includeMigrations: Boolean(args.includeMigrations) });
   if (name === 'codebone_batch') return runBatch(projectRoot, (args.operations ?? []) as Array<Record<string, unknown>>);
   if (name === 'codebone_index') return buildIndex(projectRoot, String(args.path ?? '.'), { clear: Boolean(args.clear) });
   if (name === 'codebone_doctor') return doctor(projectRoot);