@arii/boomtick-mcp 0.3.5 → 0.3.7

package/dist/tools/github.get_pr_diff.js

@@ -19,6 +19,6 @@ export async function getPrDiffHandler(args) {
         prNumber: output.prNumber,
         files: output.files,
         diffText: output.diffText,
-        truncated: output.truncated
+        isTruncated: output.isTruncated
     };
 }

package/dist/tools/repo.read_agent_context.js

@@ -1,20 +1,16 @@
 import { z } from "zod";
-import fs from "fs/promises";
-import path from "path";
 import { config } from "../config.js";
+import { loadStandaloneAgentContext } from "../lib/td-cli.js";
 export const ReadAgentContextInputSchema = z.object({});
 export async function readAgentContextHandler(_args) {
-    const contextPath = path.join(config.repoPath, ".agent-context.json");
-    try {
-        const content = await fs.readFile(contextPath, "utf-8");
-        const parsed = JSON.parse(content);
-        return {
-            status: "success",
-            ...parsed
-        };
-    }
-    catch (e) {
-        console.error("Failed to read agent context:", e.message);
-        throw new Error(`Failed to read agent context from ${contextPath}. Ensure it exists by running 'td-cli context-warm'.`);
+    const context = loadStandaloneAgentContext(config.repoPath);
+    const result = {
+        status: "success",
+        ...context
+    };
+    delete result.submodules;
+    if (result.config) {
+        delete result.config.submodules;
     }
+    return result;
 }

package/dist/tools/repo.read_agent_context.test.js

@@ -0,0 +1,10 @@
+import { describe, expect, it } from "vitest";
+import { loadStandaloneAgentContext } from "../lib/td-cli.js";
+describe("Standalone Agent Context Loader", () => {
+    it("should load agent context without submodule references", () => {
+        const context = loadStandaloneAgentContext(process.cwd());
+        expect(context).toHaveProperty("packageName");
+        expect(context).toHaveProperty("gitCommit");
+        expect(context).not.toHaveProperty("submodules");
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arii/boomtick-mcp",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "Boomtick MCP Guide: PR Rescue + Merge Conflict Agent",
   "repository": {
     "type": "git",
@@ -27,10 +27,11 @@
   "devDependencies": {
     "@types/node": "^20.17.15",
     "json-schema-to-zod": "^2.8.1",
-    "tsx": "^4.22.4",
     "shx": "^0.4.0",
+    "tsx": "^4.22.4",
     "typescript": "^5.7.3",
-    "vitest": "^4.1.9"
+    "vitest": "^4.1.9",
+    "yaml": "^2.9.0"
   },
   "scripts": {
     "build": "tsx scripts/sync-contracts.ts && tsc && shx cp src/tools/ddgs_search.py dist/tools/ && tsx scripts/sync-mcp-schemas.ts",

package/scripts/sync-contracts.ts

@@ -1,10 +1,226 @@
 import * as fs from 'fs';
 import * as path from 'path';
+import { execFileSync } from 'child_process';
+
+interface InterfaceField {
+  name: string;
+  isOptional: boolean;
+  tsType: string;
+}
+
+interface ParsedInterface {
+  name: string;
+  extendsFrom?: string;
+  fields: InterfaceField[];
+}
+
+function resolveLibPath(filename: string): string {
+  let p = path.join(process.cwd(), 'lib', filename);
+  if (!fs.existsSync(p)) {
+    p = path.join(process.cwd(), '../lib', filename);
+  }
+  return p;
+}
+
+function camelToSnake(str: string): string {
+  return str.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
+}
+
+function mapTsTypeToPython(tsType: string, typeMap: Map<string, string>): string {
+  tsType = tsType.trim();
+  if (tsType.includes('|')) {
+    const parts = tsType.split('|').map(p => p.trim());
+    const isAllLiterals = parts.every(p => (p.startsWith("'") && p.endsWith("'")) || (p.startsWith('"') && p.endsWith('"')));
+    if (isAllLiterals) {
+      return `Literal[${parts.map(p => p.replace(/"/g, "'")).join(', ')}]`;
+    }
+    const mappedParts = parts.map(p => mapTsTypeToPython(p, typeMap));
+    return `Union[${mappedParts.join(', ')}]`;
+  }
+  if (tsType.endsWith('[]')) {
+    const baseType = tsType.slice(0, -2);
+    const pyBase = mapTsTypeToPython(baseType, typeMap);
+    return `List[${pyBase}]`;
+  }
+  if (tsType.startsWith('{') && tsType.endsWith('}')) {
+    return 'Dict[str, Any]';
+  }
+  if (typeMap.has(tsType)) {
+    return tsType; // Just use the alias name
+  }
+  switch (tsType) {
+    case 'string': return 'str';
+    case 'boolean': return 'bool';
+    case 'number': return 'Union[int, float]';
+    case 'void': return 'None';
+    case 'any':
+    case 'unknown': return 'Any';
+    default: return tsType;
+  }
+}
+
+function mapFieldTsTypeToPython(fieldName: string, tsType: string, typeMap: Map<string, string>): string {
+  const normType = tsType.trim();
+  if (normType === 'number') {
+    const lower = fieldName.toLowerCase();
+    if (lower.includes('tokens') || lower === 'token' || lower.includes('count') || lower.includes('line') || lower.includes('number') || lower.includes('char') || lower.includes('ms') || lower === 'id') {
+      return 'int';
+    }
+    if (lower.includes('cost') || lower.includes('percent') || lower.includes('diff')) {
+      return 'float';
+    }
+    return 'Union[int, float]';
+  }
+  return mapTsTypeToPython(tsType, typeMap);
+}
+
+function parseInterfaceFields(body: string): InterfaceField[] {
+  const fields: InterfaceField[] = [];
+  const lines = body.split('\n');
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i].trim();
+    if (!line || line.startsWith('//') || line.startsWith('/*') || line.startsWith('*')) {
+      i++;
+      continue;
+    }
+    const match = line.match(/^(\w+)(\??)\s*:\s*([^;]+);/);
+    if (match) {
+      const name = match[1];
+      const isOptional = match[2] === '?';
+      const tsType = match[3].trim();
+      fields.push({ name, isOptional, tsType });
+    }
+    i++;
+  }
+  return fields;
+}
+
+function generatePythonContracts() {
+  const codeReviewPath = resolveLibPath('codeReviewTypes.ts');
+  const visualReviewPath = resolveLibPath('visualReviewTypes.ts');
+  const aiLoggerPath = resolveLibPath('aiLogger.ts');
+
+  const typeMap = new Map<string, string>();
+  const parsedInterfaces: ParsedInterface[] = [];
+
+  for (const filePath of [codeReviewPath, visualReviewPath, aiLoggerPath]) {
+    if (!fs.existsSync(filePath)) continue;
+    const content = fs.readFileSync(filePath, 'utf-8');
+
+    // Match type aliases
+    const typeAliasRegex = /export\s+type\s+(\w+)\s*=\s*([^;]+);/g;
+    let match;
+    while ((match = typeAliasRegex.exec(content)) !== null) {
+      const name = match[1];
+      const tsType = match[2].trim();
+      const pyType = mapTsTypeToPython(tsType, typeMap);
+      typeMap.set(name, pyType);
+    }
+
+    // Match interfaces
+    const interfaceRegex = /export\s+interface\s+(\w+)(?:\s+extends\s+(\w+))?\s*\{([\s\S]*?)\}/g;
+    while ((match = interfaceRegex.exec(content)) !== null) {
+      const name = match[1];
+      const extendsFrom = match[2];
+      const body = match[3];
+      const fields = parseInterfaceFields(body);
+      parsedInterfaces.push({ name, extendsFrom, fields });
+    }
+  }
+
+  const targetInterfaces = [
+    'IssueSummary',
+    'ReviewFinding',
+    'CodeReviewState',
+    'CodeReviewResult',
+    'VisualReviewFinding',
+    'RouteReview',
+    'AIRunLogEntry'
+  ];
+
+  let pyContent = `# Automatically generated by sync-contracts.ts. Do not edit manually.\n`;
+  pyContent += `# pylint: disable=invalid-name,missing-class-docstring,missing-module-docstring,line-too-long,unused-import\n`;
+  pyContent += `from typing import Any, Dict, List, Literal, Optional, Union\n`;
+  pyContent += `from pydantic import Field\n`;
+  pyContent += `from dev_tools.models.base import CamelCaseModel\n\n`;
+
+  for (const [name, pyType] of typeMap.entries()) {
+    if (name === 'CodeReviewParseError') {
+      pyContent += `${name} = ${pyType}\n\n`;
+    }
+  }
+
+  for (const targetName of targetInterfaces) {
+    const iface = parsedInterfaces.find(i => i.name === targetName);
+    if (!iface) {
+      console.warn(`⚠️ Warning: Interface ${targetName} not found in TS source files.`);
+      continue;
+    }
+
+    const baseClass = iface.extendsFrom ? iface.extendsFrom : 'CamelCaseModel';
+    pyContent += `class ${iface.name}(${baseClass}):\n`;
+
+    const fields = iface.fields;
+    if (fields.length === 0) {
+      pyContent += `    pass\n\n`;
+      continue;
+    }
+
+    const required: InterfaceField[] = [];
+    const optional: InterfaceField[] = [];
+    for (const f of fields) {
+      if (f.isOptional) {
+        optional.push(f);
+      } else {
+        required.push(f);
+      }
+    }
+
+    const sortedFields = [...required, ...optional];
+
+    for (const f of sortedFields) {
+      const snakeName = camelToSnake(f.name);
+      let pyType = mapFieldTsTypeToPython(f.name, f.tsType, typeMap);
+
+      if (f.isOptional) {
+        pyContent += `    ${snakeName}: Optional[${pyType}] = None\n`;
+      } else {
+        if (pyType.startsWith('List[')) {
+          pyContent += `    ${snakeName}: ${pyType} = Field(default_factory=list)\n`;
+        } else {
+          pyContent += `    ${snakeName}: ${pyType}\n`;
+        }
+      }
+    }
+    pyContent += `\n`;
+  }
+
+  let pyPath = path.join(process.cwd(), 'cli/dev_tools/models/contracts.py');
+  if (!fs.existsSync(path.dirname(pyPath))) {
+    pyPath = path.join(process.cwd(), '../cli/dev_tools/models/contracts.py');
+  }
+  fs.writeFileSync(pyPath, pyContent.trim() + '\n');
+  console.log(`Generated ${pyPath}`);
+}
 
 /**
  * Synchronizes contracts from JSON schema to Zod.
  */
 async function syncContracts() {
+  // First, generate Python models from TS contracts
+  generatePythonContracts();
+
+  // Next, regenerate the python schema so it includes our generated classes
+  let rootDir = process.cwd();
+  if (!fs.existsSync(path.join(rootDir, 'pnpm-workspace.yaml'))) {
+    rootDir = path.dirname(rootDir);
+  }
+  const pythonScriptPath = path.join(rootDir, 'cli/dev_tools/schema_gen.py');
+  console.log(`Regenerating cli-schema.json...`);
+  execFileSync('python3', [pythonScriptPath], { cwd: rootDir, stdio: 'inherit' });
+
+  // Then perform the original Zod contract generation
   let jsonSchemaToZod;
   try {
     const module = await import('json-schema-to-zod');
@@ -23,13 +239,11 @@ async function syncContracts() {
   let outputPath = path.join(process.cwd(), 'mcp/src/tools/contract.ts');
 
   if (!fs.existsSync(schemaPath)) {
-    // Try relative to package root if in extracted mode (run from root)
     schemaPath = path.join(process.cwd(), 'cli/dev_tools/cli-schema.json');
     outputPath = path.join(process.cwd(), 'mcp/src/tools/contract.ts');
   }
 
   if (!fs.existsSync(schemaPath)) {
-    // Try if run from mcp directory
     schemaPath = path.join(process.cwd(), '../cli/dev_tools/cli-schema.json');
     outputPath = path.join(process.cwd(), 'src/tools/contract.ts');
   }
@@ -46,24 +260,20 @@ async function syncContracts() {
   tsContent += `import { z } from "zod";\n\n`;
 
   for (const [name, schema] of Object.entries(models)) {
-    // Get the raw Zod expression without any variable assignment or imports
     const zodExpression = jsonSchemaToZod(schema as any, { module: 'none' });
 
     tsContent += `export const ${name}Schema = ${zodExpression};\n\n`;
     tsContent += `export type ${name} = z.infer<typeof ${name}Schema>;\n\n`;
 
-    // Also export the raw JSON schema for MCP definitions
     tsContent += `export const ${name}JsonSchema = ${JSON.stringify(schema, null, 2)} as const;\n\n`;
   }
 
-  // Normalize newlines to \n and ensure exactly one trailing newline at EOF
   const finalContent = tsContent.replace(/\r\n/g, '\n').trimEnd() + '\n';
 
   fs.writeFileSync(outputPath, finalContent);
   console.log(`Generated ${outputPath}`);
 }
 
-// Ensure execution is awaited and errors are caught
 (async () => {
   try {
     await syncContracts();

package/src/lib/td-cli.ts

@@ -1,4 +1,7 @@
 import { runCommand } from "../lib/shell.js";
+import { execSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
 
 export interface TDCliResponse {
   status: string;
@@ -6,6 +9,38 @@ export interface TDCliResponse {
   [key: string]: any;
 }
 
+export interface AgentContext {
+  packageName: string;
+  gitCommit: string;
+  config: Record<string, unknown>;
+}
+
+export const loadStandaloneAgentContext = (repoRoot: string = process.cwd()): AgentContext => {
+  const configPath = path.join(repoRoot, "project_config.json");
+  let config: Record<string, unknown> = {};
+
+  if (fs.existsSync(configPath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    } catch (e) {
+      console.warn(`[MCP Warning] Failed to parse ${configPath}:`, e);
+    }
+  }
+
+  let gitCommit = "unknown";
+  try {
+    gitCommit = execSync("git rev-parse HEAD", { cwd: repoRoot, encoding: "utf-8" }).trim();
+  } catch {
+    // Fallback if git is unavailable (e.g. Docker container without git)
+  }
+
+  return {
+    packageName: (config.packageName as string) ?? "boomtick",
+    gitCommit,
+    config,
+  };
+};
+
 function tryParseJson(text: string): TDCliResponse | null {
   try {
     return JSON.parse(text) as TDCliResponse;