improvements for python

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

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "codebone",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Agent-native CLI and MCP server for compact code context.",
   "type": "module",
   "bin": {

package.json

@@ -162,9 +162,9 @@ function isGeneratedOrVendor(filePath: string): boolean {
 }
 
 function inferTestRelations(fileRecords: Array<{ path: string; imports: string[] }>, edges: Array<{ from: string; resolved?: string }>) {
-  const sourceFiles = new Set(fileRecords.map((record) => record.path).filter((filePath) => !isTestPath(filePath)));
+  const sourceFiles = new Set(fileRecords.map((record) => record.path).filter((filePath) => !isTestPath(filePath) && !isInitFile(filePath)));
   const relations: Array<{ test: string; source: string; reason: string }> = [];
-  for (const test of fileRecords.filter((record) => isTestPath(record.path))) {
+  for (const test of fileRecords.filter((record) => isTestPath(record.path) && !isInitFile(record.path))) {
     for (const edge of edges.filter((item) => item.from === test.path && item.resolved && sourceFiles.has(item.resolved))) {
       relations.push({ test: test.path, source: edge.resolved!, reason: 'import' });
     }
@@ -187,6 +187,10 @@ function isTestPath(filePath: string): boolean {
   return /(^|\/)(test|tests|spec|__tests__)(\/|$)|\.(test|spec)\.|(^|\/)test_[^/]+\.py$|(^|\/)[^/]+_test\.py$/.test(filePath);
 }
 
+function isInitFile(filePath: string): boolean {
+  return /(^|\/)__init__\.py$/.test(filePath);
+}
+
 function buildArchitectureSummary(fileRecords: Array<{ path: string; imports: string[]; symbols: ReturnType<typeof flattenSymbols> }>, edges: Array<{ from: string; source: string; resolved?: string }>, testRelations: Array<{ test: string; source: string; reason: string }>) {
   const files = fileRecords.map((record) => ({
     path: record.path,
@@ -199,20 +203,26 @@ function buildArchitectureSummary(fileRecords: Array<{ path: string; imports: st
     const handler = record.symbols
       .filter((symbol) => ['function', 'method'].includes(symbol.kind) && symbol.startLine > route.startLine)
       .sort((a, b) => a.startLine - b.startLine)[0];
-    return { file: record.path, route: route.name, line: route.startLine, handler: handler?.qualifiedName };
+    return { file: record.path, route: route.name, line: route.startLine, handler: route.source ?? handler?.qualifiedName };
   }));
 
-  const dependencies = uniqueBy(fileRecords.flatMap((record) => record.symbols.filter((symbol) => symbol.kind === 'dependency').map((symbol) => ({ file: record.path, key: symbol.name, line: symbol.startLine }))), (item) => `${item.file}:${item.key}:${item.line}`);
+  const dependencies = buildAppDependencyGraph(fileRecords);
   const tables = uniqueBy(fileRecords.flatMap((record) => record.symbols.filter((symbol) => symbol.kind === 'table').map((symbol) => ({ file: record.path, name: symbol.name, line: symbol.startLine }))), (item) => `${item.file}:${item.name}`);
   const localImports = edges.filter((edge) => edge.resolved).map((edge) => ({ from: edge.from, to: edge.resolved!, source: edge.source }));
   const serviceEdges = localImports.filter((edge) => /service|api|route|handler|view|dao|task|worker|creator/i.test(`${edge.from} ${edge.to} ${edge.source}`));
-  return { files, routes, dependencies, tables, serviceEdges: serviceEdges.slice(0, 30), testRelations };
+  const rpc = buildRpcSummary(fileRecords, dependencies);
+  return { files, routes, rpc, dependencies, tables, serviceEdges: serviceEdges.slice(0, 20), testRelations };
 }
 
 function renderArchitectureSummary(summary: ReturnType<typeof buildArchitectureSummary>): string {
   const sections: string[] = ['Architecture summary'];
   if (summary.routes.length) sections.push(`Routes -> handlers:\n${summary.routes.map((item) => `  ${item.route} -> ${item.handler ?? 'unknown'} (${item.file}:${item.line})`).join('\n')}`);
-  if (summary.dependencies.length) sections.push(`App dependencies:\n${summary.dependencies.map((item) => `  app["${item.key}"] (${item.file}:${item.line})`).join('\n')}`);
+  if (summary.rpc.length) sections.push(`RPC summary:\n${summary.rpc.map((item) => `  ${item.name} (${item.file}:${item.line})${item.dependencies.length ? ` uses app[${item.dependencies.map((key) => `"${key}"`).join(', ')}]` : ''}`).join('\n')}`);
+  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}`).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}`;
+  }).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.serviceEdges.length) sections.push(`Local dependency flow:\n${summary.serviceEdges.map((item) => `  ${item.from} -> ${item.to}`).join('\n')}`);
   if (summary.files.length) sections.push(`Key files:\n${summary.files.slice(0, 30).map((item) => {
@@ -227,6 +237,30 @@ function renderArchitectureSummary(summary: ReturnType<typeof buildArchitectureS
   return sections.join('\n\n');
 }
 
+function buildAppDependencyGraph(fileRecords: Array<{ path: string; symbols: ReturnType<typeof flattenSymbols> }>) {
+  const byKey = new Map<string, { key: string; writes: Array<{ file: string; line: number }>; reads: 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 usage = { file: record.path, line: symbol.startLine };
+      if (/\b(?:app|request\.app)\[['"][^'"]+['"]\]\s*=/.test(symbol.signature)) entry.writes.push(usage);
+      else entry.reads.push(usage);
+      byKey.set(symbol.name, entry);
+    }
+  }
+  return [...byKey.values()].sort((a, b) => Number(b.writes.length > 0) - Number(a.writes.length > 0) || a.key.localeCompare(b.key));
+}
+
+function buildRpcSummary(fileRecords: Array<{ path: string; symbols: ReturnType<typeof flattenSymbols> }>, dependencies: ReturnType<typeof buildAppDependencyGraph>) {
+  const dependencyKeys = new Set(dependencies.map((dependency) => dependency.key));
+  return fileRecords.flatMap((record) => record.symbols.filter((symbol) => ['function', 'method'].includes(symbol.kind) && symbol.name.startsWith('rpc_')).map((symbol) => {
+    const deps = record.symbols
+      .filter((item) => item.kind === 'dependency' && item.startLine >= symbol.startLine && item.endLine <= symbol.endLine && dependencyKeys.has(item.name))
+      .map((item) => item.name);
+    return { file: record.path, name: symbol.qualifiedName, line: symbol.startLine, dependencies: Array.from(new Set(deps)) };
+  }));
+}
+
 function uniqueBy<T>(items: T[], key: (item: T) => string): T[] {
   const seen = new Set<string>();
   return items.filter((item) => {

src/core/context.ts

@@ -18,7 +18,7 @@ export async function doctor(root: string) {
   warnings.push(...missing.map((grammar) => `grammar_missing:${grammar.language}`));
   return {
     schemaVersion: SCHEMA_VERSION,
-    version: '0.1.1',
+    version: '0.1.2',
     node: process.version,
     grammars: { mode: 'tree-sitter-wasm+syntax-fallback', loaded: loaded.length, fallback: 14 - loaded.length, missing: missing.length, gold: loaded.map((grammar) => grammar.language), missingLanguages: missing.map((grammar) => grammar.language) },
     indexDirectory: warnings.includes('index_not_writable') ? 'failed' : 'ok',

src/core/doctor.ts

@@ -76,8 +76,11 @@ function resolvePythonImport(from: string, source: string, fileSet: Set<string>)
   const direct = directCandidates.find((candidate) => fileSet.has(candidate));
   if (direct) return direct;
 
+  if (!source.startsWith('.') && !source.includes('.')) return undefined;
+
   const suffixMatches = [...fileSet]
     .filter((filePath) => filePath === `${modulePath}.py` || filePath.endsWith(`/${modulePath}.py`) || filePath === path.posix.join(modulePath, '__init__.py') || filePath.endsWith(`/${modulePath}/__init__.py`))
+    .filter((filePath) => !/(^|\/)tests?\//.test(filePath))
     .sort((a, b) => a.length - b.length || a.localeCompare(b));
   return suffixMatches[0];
 }

src/core/graph.ts

@@ -232,12 +232,8 @@ function extractPythonLandmarks(lines: string[]): Candidate[] {
   for (let index = 0; index < lines.length; index += 1) {
     const trimmed = lines[index].trim();
     const lineNo = index + 1;
-    const routeMatch = trimmed.match(/^(?:@\w+(?:\.\w+)*\.(get|post|put|patch|delete|route)\(|(?:\w+\.)?router\.add_(get|post|put|patch|delete|route)\(|web\.(get|post|put|patch|delete|route)\()\s*['"]([^'"]+)['"]/) ?? trimmed.match(/add_routes\(\s*\[\s*web\.(get|post|put|patch|delete|route)\(\s*['"]([^'"]+)['"]/);
-    if (routeMatch) {
-      const method = (routeMatch[1] ?? routeMatch[2] ?? routeMatch[3] ?? routeMatch[5] ?? 'route').toUpperCase();
-      const routePath = routeMatch[4] ?? routeMatch[6];
-      out.push({ kind: 'route', name: `${method} ${routePath}`, signature: trimmed, startLine: lineNo, endLine: lineNo, exported: true });
-    }
+    const route = pythonRoute(trimmed);
+    if (route) out.push({ kind: 'route', name: `${route.method} ${route.path}`, source: route.handler, signature: trimmed, startLine: lineNo, endLine: lineNo, exported: true });
     const dependencyMatch = trimmed.match(/\bapp\[['"]([^'"]+)['"]\]|\brequest\.app\[['"]([^'"]+)['"]\]/);
     if (dependencyMatch) out.push({ kind: 'dependency', name: dependencyMatch[1] ?? dependencyMatch[2], signature: trimmed, startLine: lineNo, endLine: lineNo, exported: true });
     const tableName = pythonTableName(lines, index);
@@ -246,6 +242,19 @@ function extractPythonLandmarks(lines: string[]): Candidate[] {
   return out;
 }
 
+function pythonRoute(trimmed: string): { method: string; path: string; handler?: string } | undefined {
+  const decorator = trimmed.match(/^@\w+(?:\.\w+)*\.(get|post|put|patch|delete|route)\(\s*['"]([^'"]+)['"]/);
+  if (decorator) return { method: decorator[1].toUpperCase(), path: decorator[2] };
+
+  const addRoute = trimmed.match(/(?:\w+\.)?router\.add_(get|post|put|patch|delete|route)\(\s*['"]([^'"]+)['"]\s*(?:,\s*([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)?))?/);
+  if (addRoute) return { method: addRoute[1].toUpperCase(), path: addRoute[2], handler: addRoute[3] };
+
+  const webRoute = trimmed.match(/\bweb\.(get|post|put|patch|delete|route)\(\s*['"]([^'"]+)['"]\s*(?:,\s*([A-Za-z_]\w*(?:\.[A-Za-z_]\w*)?))?/);
+  if (webRoute) return { method: webRoute[1].toUpperCase(), path: webRoute[2], handler: webRoute[3] };
+
+  return undefined;
+}
+
 function pythonTableName(lines: string[], index: number): string | undefined {
   const text = lines.slice(index, Math.min(lines.length, index + 5)).map((line) => line.trim()).join(' ');
   return text.match(/(?:^|=\s*)(?:\w+\.)?Table\(\s*['"]([^'"]+)['"]/)?.[1]

src/core/skeleton.ts

@@ -18,7 +18,7 @@ const program = new Command();
 program
   .name('codebone')
   .description('Agent-native CLI and MCP server for compact code context')
-  .version('0.1.1')
+  .version('0.1.2')
   .option('--root <path>', 'project root', '.')
   .option('--format <format>', 'text or json', 'text')
   .option('--budget <tokens>', 'token budget')

src/index.ts

@@ -42,7 +42,7 @@ export function startMcpServer(): void {
 }
 
 export function createSdkServer(projectRoot: string): Server {
-  const server = new Server({ name: 'codebone', version: '0.1.1' }, { capabilities: { tools: {}, resources: {}, prompts: {} } });
+  const server = new Server({ name: 'codebone', version: '0.1.2' }, { capabilities: { tools: {}, resources: {}, prompts: {} } });
   server.setRequestHandler(ListToolsRequestSchema, () => ({ tools }));
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
@@ -67,7 +67,7 @@ export async function handleMcpRequest(projectRoot: string, message: JsonRpc): P
   if (!message.method) return;
   try {
     if (message.method === 'initialize') {
-      return { id: message.id, result: { protocolVersion: '2024-11-05', capabilities: { tools: {}, resources: {}, prompts: {} }, serverInfo: { name: 'codebone', version: '0.1.1' } } };
+      return { id: message.id, result: { protocolVersion: '2024-11-05', capabilities: { tools: {}, resources: {}, prompts: {} }, serverInfo: { name: 'codebone', version: '0.1.2' } } };
     } else if (message.method === 'notifications/initialized') {
       return;
     } else if (message.method === 'tools/list') {

src/mcp-server.ts

@@ -61,7 +61,14 @@ describe('context ranking', () => {
       '    request.app["dao"]',
       '    return None',
       '',
+      'def setup(app):',
+      '    app["dao"] = UserDao()',
+      '    app.router.add_routes([',
+      '        web.post("/rpc", rpc_get_user),',
+      '    ])',
+      '',
     ].join('\n'));
+    await fs.writeFile(path.join(root, 'tests/__init__.py'), '');
     await fs.writeFile(path.join(root, 'tests/test_user.py'), 'from app.dao.user import UserDao\n\ndef test_user():\n    assert UserDao\n');
 
     const data = await buildContext(root, { goal: 'user api architecture', mode: 'architecture', budget: 1000 });
@@ -70,9 +77,14 @@ describe('context ranking', () => {
     expect(data.mode).toBe('architecture');
     expect(content).toContain('Routes -> handlers');
     expect(content).toContain('GET /users/{user_id} -> rpc_get_user');
-    expect(content).toContain('app["dao"]');
+    expect(content).toContain('POST /rpc -> rpc_get_user');
+    expect(content).toContain('RPC summary');
+    expect(content).toContain('rpc_get_user');
+    expect(content).toContain('App dependency graph');
+    expect(content).toContain('app["dao"] created: app/api/users.py');
     expect(content).toContain('SQLAlchemy tables:\n  users');
     expect((content.match(/users \(app\/db\.py/g) ?? [])).toHaveLength(1);
     expect(content).toContain('Suggested tests');
+    expect(content).not.toContain('tests/__init__.py');
   });
 });

tests/context.test.ts

@@ -50,4 +50,16 @@ describe('import/export graph', () => {
     expect(graph.edges).toContainEqual(expect.objectContaining({ from: 'app/api/users.py', source: 'app.tasks.worker', resolved: 'app/tasks/worker.py' }));
     expect(graph.summary.resolvedImports).toBe(3);
   });
+
+  it('does not resolve Python stdlib imports to test package name collisions', async () => {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'codebone-python-stdlib-'));
+    await fs.mkdir(path.join(root, 'app'), { recursive: true });
+    await fs.mkdir(path.join(root, 'tests/logging'), { recursive: true });
+    await fs.writeFile(path.join(root, 'app/service.py'), 'import logging\n\ndef run():\n    return logging.getLogger(__name__)\n');
+    await fs.writeFile(path.join(root, 'tests/logging/__init__.py'), '');
+
+    const graph = await buildImportGraph(root, '.');
+
+    expect(graph.edges).toContainEqual(expect.objectContaining({ from: 'app/service.py', source: 'logging', resolved: undefined }));
+  });
 });