@praneeth_54/agentdoctor 2.0.0 → 2.0.1

package/dist/languages/index.js

@@ -0,0 +1,76 @@
+import { detectLanguage } from "./types.js";
+import { javascriptAdapter, typescriptAdapter } from "./typescript.js";
+import { pythonAdapter } from "./python.js";
+import { phpAdapter } from "./php.js";
+import { goAdapter } from "./go.js";
+function unsupportedAdapter(id, extensions, reason) {
+    return {
+        id,
+        extensions,
+        capabilities: () => ({
+            parse: "unsupported",
+            symbols: "unsupported",
+            definitions: "unsupported",
+            references: "unsupported",
+            imports: "unsupported",
+            calls: "unsupported",
+            diagnostics: "unsupported",
+        }),
+        async parse(filePath, _source) {
+            return {
+                language: id,
+                file: filePath,
+                ok: false,
+                capabilities: this.capabilities(),
+                symbols: [],
+                imports: [],
+                calls: [],
+                diagnostics: [reason],
+                limitations: [
+                    reason,
+                    "No regex fallback is offered under an AST claim — capability remains unsupported until a mature parser is integrated",
+                ],
+            };
+        },
+    };
+}
+/** Languages with real AST backends today (or honest unsupported stubs). */
+export const languageAdapters = [
+    typescriptAdapter,
+    javascriptAdapter,
+    pythonAdapter,
+    phpAdapter,
+    goAdapter,
+    unsupportedAdapter("java", [".java"], "Java AST requires an external parser (e.g. tree-sitter-java or javaparser); not bundled"),
+    unsupportedAdapter("kotlin", [".kt", ".kts"], "Kotlin AST requires an external parser; not bundled"),
+    unsupportedAdapter("rust", [".rs"], "Rust AST requires syn/rustc or tree-sitter-rust; not bundled"),
+    unsupportedAdapter("dart", [".dart"], "Dart AST requires Dart analyzer APIs; not bundled"),
+];
+export function getAdapterForFile(filePath) {
+    const lang = detectLanguage(filePath);
+    if (lang === "unknown")
+        return null;
+    return languageAdapters.find((a) => a.id === lang) ?? null;
+}
+export async function parseSourceFile(filePath, source) {
+    const adapter = getAdapterForFile(filePath);
+    if (!adapter) {
+        return {
+            language: "unknown",
+            file: filePath,
+            ok: false,
+            capabilities: {},
+            symbols: [],
+            imports: [],
+            calls: [],
+            diagnostics: ["unknown language"],
+            limitations: ["No language adapter for this file extension"],
+        };
+    }
+    return adapter.parse(filePath, source);
+}
+export { detectLanguage } from "./types.js";
+export { typescriptAdapter, javascriptAdapter } from "./typescript.js";
+export { pythonAdapter, pythonAvailable } from "./python.js";
+export { phpAdapter, phpAvailable } from "./php.js";
+export { goAdapter, goAvailable } from "./go.js";

package/dist/languages/php.d.ts

@@ -0,0 +1,7 @@
+import type { LanguageAdapter } from "./types.js";
+/**
+ * Real PHP token extractor via `php -r` + token_get_all (requires `php` on PATH).
+ * Not regex. If php is missing, capabilities are unsupported.
+ */
+export declare function phpAvailable(): boolean;
+export declare const phpAdapter: LanguageAdapter;

package/dist/languages/php.js

@@ -0,0 +1,193 @@
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+function sid(kind, key) {
+    return `${kind}:${createHash("sha256").update(key).digest("hex").slice(0, 12)}`;
+}
+/**
+ * Real PHP token extractor via `php -r` + token_get_all (requires `php` on PATH).
+ * Not regex. If php is missing, capabilities are unsupported.
+ */
+export function phpAvailable() {
+    const r = spawnSync("php", ["-r", "echo PHP_VERSION;"], { encoding: "utf8" });
+    return r.status === 0 && Boolean(r.stdout?.trim());
+}
+const PHP_EXTRACTOR = `
+$source = stream_get_contents(STDIN);
+$path = $argv[1] ?? "stdin.php";
+if ($source === false || $source === "") {
+  echo json_encode(["ok" => false, "error" => "empty source", "symbols" => [], "imports" => [], "calls" => []]);
+  exit(0);
+}
+if (strpos($source, "<?") === false) {
+  $source = "<?php\\n" . $source;
+}
+$tokens = @token_get_all($source);
+if (!is_array($tokens)) {
+  echo json_encode(["ok" => false, "error" => "token_get_all failed", "symbols" => [], "imports" => [], "calls" => []]);
+  exit(0);
+}
+$symbols = [];
+$imports = [];
+$calls = [];
+$count = count($tokens);
+for ($i = 0; $i < $count; $i++) {
+  $t = $tokens[$i];
+  if (!is_array($t)) continue;
+  [$id, $text, $line] = $t;
+  if ($id === T_FUNCTION) {
+    for ($j = $i + 1; $j < $count; $j++) {
+      $n = $tokens[$j];
+      if (!is_array($n)) continue;
+      if ($n[0] === T_STRING) {
+        $symbols[] = ["name" => $n[1], "kind" => "function", "line" => $n[2]];
+        break;
+      }
+      if ($n[0] === T_WHITESPACE || $n[0] === T_COMMENT || $n[0] === T_DOC_COMMENT) continue;
+      break;
+    }
+  } elseif ($id === T_CLASS || $id === T_INTERFACE || $id === T_TRAIT) {
+    $kind = $id === T_CLASS ? "class" : ($id === T_INTERFACE ? "interface" : "trait");
+    for ($j = $i + 1; $j < $count; $j++) {
+      $n = $tokens[$j];
+      if (!is_array($n)) continue;
+      if ($n[0] === T_STRING) {
+        $symbols[] = ["name" => $n[1], "kind" => $kind, "line" => $n[2]];
+        break;
+      }
+      if ($n[0] === T_WHITESPACE || $n[0] === T_COMMENT || $n[0] === T_DOC_COMMENT) continue;
+      break;
+    }
+  } elseif ($id === T_USE) {
+    $spec = "";
+    for ($j = $i + 1; $j < $count; $j++) {
+      $n = $tokens[$j];
+      if (is_array($n)) {
+        if ($n[0] === T_STRING || $n[0] === T_NS_SEPARATOR || $n[0] === T_NAME_QUALIFIED || $n[0] === T_NAME_FULLY_QUALIFIED) {
+          $spec .= $n[1];
+          continue;
+        }
+        if ($n[0] === T_WHITESPACE) continue;
+        break;
+      }
+      if ($n === ";" || $n === "{") break;
+    }
+    if ($spec !== "") $imports[] = ["specifier" => $spec];
+  } elseif ($id === T_STRING) {
+    $next = $tokens[$i + 1] ?? null;
+    $prev = $tokens[$i - 1] ?? null;
+    $prevIsObject = is_array($prev) && ($prev[0] === T_OBJECT_OPERATOR || $prev[0] === T_NULLSAFE_OBJECT_OPERATOR || $prev[0] === T_DOUBLE_COLON);
+    if ($next === "(" && !$prevIsObject) {
+      $calls[] = ["callee" => $text, "line" => $line];
+    }
+  }
+}
+echo json_encode(["ok" => true, "symbols" => $symbols, "imports" => $imports, "calls" => $calls], JSON_UNESCAPED_SLASHES);
+`;
+export const phpAdapter = {
+    id: "php",
+    extensions: [".php"],
+    capabilities: () => {
+        const ok = phpAvailable();
+        const v = ok ? "supported" : "unsupported";
+        return {
+            parse: v,
+            symbols: v,
+            definitions: v,
+            imports: v,
+            calls: v,
+            references: "unsupported",
+            diagnostics: ok ? "supported" : "unsupported",
+        };
+    },
+    async parse(filePath, source) {
+        if (!phpAvailable()) {
+            return {
+                language: "php",
+                file: filePath,
+                ok: false,
+                capabilities: phpAdapter.capabilities(),
+                symbols: [],
+                imports: [],
+                calls: [],
+                diagnostics: ["php not available on PATH"],
+                limitations: ["PHP adapter requires php CLI with token_get_all"],
+            };
+        }
+        const r = spawnSync("php", ["-r", PHP_EXTRACTOR, "--", filePath], {
+            input: source,
+            encoding: "utf8",
+            maxBuffer: 8 * 1024 * 1024,
+        });
+        if (r.status !== 0 || !r.stdout) {
+            return {
+                language: "php",
+                file: filePath,
+                ok: false,
+                capabilities: phpAdapter.capabilities(),
+                symbols: [],
+                imports: [],
+                calls: [],
+                diagnostics: [r.stderr || "php extractor failed"],
+                limitations: [],
+            };
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(r.stdout);
+        }
+        catch {
+            return {
+                language: "php",
+                file: filePath,
+                ok: false,
+                capabilities: phpAdapter.capabilities(),
+                symbols: [],
+                imports: [],
+                calls: [],
+                diagnostics: ["invalid JSON from php extractor"],
+                limitations: [],
+            };
+        }
+        if (!parsed.ok) {
+            return {
+                language: "php",
+                file: filePath,
+                ok: false,
+                capabilities: phpAdapter.capabilities(),
+                symbols: [],
+                imports: [],
+                calls: [],
+                diagnostics: [parsed.error ?? "parse error"],
+                limitations: [],
+            };
+        }
+        return {
+            language: "php",
+            file: filePath,
+            ok: true,
+            capabilities: phpAdapter.capabilities(),
+            symbols: parsed.symbols.map((s) => ({
+                id: sid(s.kind, `${filePath}:${s.name}:${s.line}`),
+                name: s.name,
+                kind: s.kind,
+                file: filePath,
+                line: s.line,
+                evidence: "ast",
+            })),
+            imports: parsed.imports.map((i) => ({
+                fromFile: filePath,
+                specifier: i.specifier,
+                evidence: "ast",
+            })),
+            calls: parsed.calls.map((c) => ({
+                fromFile: filePath,
+                callee: c.callee,
+                evidence: "ast",
+            })),
+            diagnostics: [],
+            limitations: [
+                "PHP token_get_all single-file extract — not a full php-parser AST; cross-file refs unsupported",
+            ],
+        };
+    },
+};

package/dist/languages/python.d.ts

@@ -0,0 +1,7 @@
+import type { LanguageAdapter } from "./types.js";
+/**
+ * Real Python AST via the CPython `ast` module (requires `python3` on PATH).
+ * Not regex. If python3 is missing, capabilities are unsupported.
+ */
+export declare function pythonAvailable(): boolean;
+export declare const pythonAdapter: LanguageAdapter;

package/dist/languages/python.js

@@ -0,0 +1,150 @@
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+function sid(kind, key) {
+    return `${kind}:${createHash("sha256").update(key).digest("hex").slice(0, 12)}`;
+}
+/**
+ * Real Python AST via the CPython `ast` module (requires `python3` on PATH).
+ * Not regex. If python3 is missing, capabilities are unsupported.
+ */
+export function pythonAvailable() {
+    const r = spawnSync("python3", ["-c", "import ast, json"], { encoding: "utf8" });
+    return r.status === 0;
+}
+const PY_EXTRACTOR = `
+import ast, json, sys
+source = sys.stdin.read()
+path = sys.argv[1]
+try:
+    tree = ast.parse(source, filename=path)
+except SyntaxError as e:
+    print(json.dumps({"ok": False, "error": str(e), "symbols": [], "imports": [], "calls": []}))
+    sys.exit(0)
+symbols = []
+imports = []
+calls = []
+for node in ast.walk(tree):
+    if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+        symbols.append({"name": node.name, "kind": "function", "line": node.lineno})
+    elif isinstance(node, ast.ClassDef):
+        symbols.append({"name": node.name, "kind": "class", "line": node.lineno})
+    elif isinstance(node, ast.Import):
+        for a in node.names:
+            imports.append({"specifier": a.name})
+    elif isinstance(node, ast.ImportFrom):
+        mod = node.module or ""
+        imports.append({"specifier": mod if mod else "."})
+    elif isinstance(node, ast.Call):
+        try:
+            callee = ast.unparse(node.func)
+        except Exception:
+            callee = type(node.func).__name__
+        calls.append({"callee": callee})
+print(json.dumps({"ok": True, "symbols": symbols, "imports": imports, "calls": calls}))
+`;
+export const pythonAdapter = {
+    id: "python",
+    extensions: [".py"],
+    capabilities: () => {
+        const ok = pythonAvailable();
+        const v = ok ? "supported" : "unsupported";
+        return {
+            parse: v,
+            symbols: v,
+            definitions: v,
+            imports: v,
+            calls: v,
+            references: "unsupported",
+            diagnostics: ok ? "supported" : "unsupported",
+        };
+    },
+    async parse(filePath, source) {
+        if (!pythonAvailable()) {
+            return {
+                language: "python",
+                file: filePath,
+                ok: false,
+                capabilities: pythonAdapter.capabilities(),
+                symbols: [],
+                imports: [],
+                calls: [],
+                diagnostics: ["python3 not available on PATH"],
+                limitations: ["Python AST adapter requires python3 with stdlib ast module"],
+            };
+        }
+        const r = spawnSync("python3", ["-c", PY_EXTRACTOR, filePath], {
+            input: source,
+            encoding: "utf8",
+            maxBuffer: 8 * 1024 * 1024,
+        });
+        if (r.status !== 0 || !r.stdout) {
+            return {
+                language: "python",
+                file: filePath,
+                ok: false,
+                capabilities: pythonAdapter.capabilities(),
+                symbols: [],
+                imports: [],
+                calls: [],
+                diagnostics: [r.stderr || "python3 extractor failed"],
+                limitations: [],
+            };
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(r.stdout);
+        }
+        catch {
+            return {
+                language: "python",
+                file: filePath,
+                ok: false,
+                capabilities: pythonAdapter.capabilities(),
+                symbols: [],
+                imports: [],
+                calls: [],
+                diagnostics: ["invalid JSON from python extractor"],
+                limitations: [],
+            };
+        }
+        if (!parsed.ok) {
+            return {
+                language: "python",
+                file: filePath,
+                ok: false,
+                capabilities: pythonAdapter.capabilities(),
+                symbols: [],
+                imports: [],
+                calls: [],
+                diagnostics: [parsed.error ?? "parse error"],
+                limitations: [],
+            };
+        }
+        return {
+            language: "python",
+            file: filePath,
+            ok: true,
+            capabilities: pythonAdapter.capabilities(),
+            symbols: parsed.symbols.map((s) => ({
+                id: sid(s.kind, `${filePath}:${s.name}:${s.line}`),
+                name: s.name,
+                kind: s.kind,
+                file: filePath,
+                line: s.line,
+                evidence: "ast",
+            })),
+            imports: parsed.imports.map((i) => ({
+                fromFile: filePath,
+                specifier: i.specifier,
+                evidence: "ast",
+            })),
+            calls: parsed.calls.map((c) => ({
+                fromFile: filePath,
+                callee: c.callee,
+                evidence: "ast",
+            })),
+            diagnostics: [],
+            limitations: ["Cross-file references not resolved; CPython ast single-file only"],
+        };
+    },
+};

package/dist/languages/types.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Language adapter contract — real parsers only.
+ * Unsupported capabilities must be reported as unsupported, never as inferred AST.
+ */
+export type LanguageId = "typescript" | "javascript" | "python" | "java" | "kotlin" | "go" | "rust" | "php" | "dart" | "unknown";
+export type AdapterCapability = "parse" | "symbols" | "definitions" | "references" | "imports" | "calls" | "diagnostics";
+export interface LanguageSymbol {
+    id: string;
+    name: string;
+    kind: string;
+    file: string;
+    line?: number;
+    evidence: "ast" | "unsupported";
+}
+export interface LanguageImport {
+    fromFile: string;
+    specifier: string;
+    evidence: "ast" | "unsupported";
+}
+export interface LanguageCall {
+    fromFile: string;
+    callee: string;
+    evidence: "ast" | "unsupported";
+}
+export interface ParseResult {
+    language: LanguageId;
+    file: string;
+    ok: boolean;
+    capabilities: Partial<Record<AdapterCapability, "supported" | "unsupported">>;
+    symbols: LanguageSymbol[];
+    imports: LanguageImport[];
+    calls: LanguageCall[];
+    diagnostics: string[];
+    limitations: string[];
+}
+export interface LanguageAdapter {
+    id: LanguageId;
+    extensions: string[];
+    capabilities(): Partial<Record<AdapterCapability, "supported" | "unsupported">>;
+    parse(filePath: string, source: string): Promise<ParseResult>;
+}
+export declare function detectLanguage(filePath: string): LanguageId;

package/dist/languages/types.js

@@ -0,0 +1,26 @@
+/**
+ * Language adapter contract — real parsers only.
+ * Unsupported capabilities must be reported as unsupported, never as inferred AST.
+ */
+export function detectLanguage(filePath) {
+    const lower = filePath.toLowerCase();
+    if (/\.tsx?$/.test(lower) || /\.mts$/.test(lower) || /\.cts$/.test(lower))
+        return "typescript";
+    if (/\.jsx?$/.test(lower) || /\.mjs$/.test(lower) || /\.cjs$/.test(lower))
+        return "javascript";
+    if (/\.py$/.test(lower))
+        return "python";
+    if (/\.java$/.test(lower))
+        return "java";
+    if (/\.kt$/.test(lower) || /\.kts$/.test(lower))
+        return "kotlin";
+    if (/\.go$/.test(lower))
+        return "go";
+    if (/\.rs$/.test(lower))
+        return "rust";
+    if (/\.php$/.test(lower))
+        return "php";
+    if (/\.dart$/.test(lower))
+        return "dart";
+    return "unknown";
+}

package/dist/languages/typescript.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageAdapter } from "./types.js";
+export declare const typescriptAdapter: LanguageAdapter;
+export declare const javascriptAdapter: LanguageAdapter;

package/dist/languages/typescript.js

@@ -0,0 +1,95 @@
+import { createHash } from "node:crypto";
+import ts from "typescript";
+function sid(kind, key) {
+    return `${kind}:${createHash("sha256").update(key).digest("hex").slice(0, 12)}`;
+}
+function parseTsJs(filePath, source, language) {
+    const kind = language === "typescript" ? ts.ScriptKind.TS : ts.ScriptKind.JS;
+    const sf = ts.createSourceFile(filePath, source, ts.ScriptTarget.ES2022, true, kind);
+    const symbols = [];
+    const imports = [];
+    const calls = [];
+    const diagnostics = [];
+    const visit = (node) => {
+        if (ts.isFunctionDeclaration(node) && node.name) {
+            const name = node.name.text;
+            symbols.push({
+                id: sid("fn", `${filePath}:${name}`),
+                name,
+                kind: "function",
+                file: filePath,
+                line: sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1,
+                evidence: "ast",
+            });
+        }
+        if (ts.isClassDeclaration(node) && node.name) {
+            const name = node.name.text;
+            symbols.push({
+                id: sid("class", `${filePath}:${name}`),
+                name,
+                kind: "class",
+                file: filePath,
+                line: sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1,
+                evidence: "ast",
+            });
+        }
+        if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+            imports.push({
+                fromFile: filePath,
+                specifier: node.moduleSpecifier.text,
+                evidence: "ast",
+            });
+        }
+        if (ts.isCallExpression(node)) {
+            const callee = node.expression.getText(sf);
+            calls.push({ fromFile: filePath, callee, evidence: "ast" });
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return {
+        language,
+        file: filePath,
+        ok: true,
+        capabilities: {
+            parse: "supported",
+            symbols: "supported",
+            definitions: "supported",
+            imports: "supported",
+            calls: "supported",
+            references: "unsupported",
+            diagnostics: "unsupported",
+        },
+        symbols,
+        imports,
+        calls,
+        diagnostics,
+        limitations: [
+            "TypeScript compiler API parse (single-file); cross-file references unsupported in adapter",
+        ],
+    };
+}
+export const typescriptAdapter = {
+    id: "typescript",
+    extensions: [".ts", ".tsx", ".mts", ".cts"],
+    capabilities: () => ({
+        parse: "supported",
+        symbols: "supported",
+        definitions: "supported",
+        imports: "supported",
+        calls: "supported",
+        references: "unsupported",
+        diagnostics: "unsupported",
+    }),
+    async parse(filePath, source) {
+        return parseTsJs(filePath, source, "typescript");
+    },
+};
+export const javascriptAdapter = {
+    id: "javascript",
+    extensions: [".js", ".jsx", ".mjs", ".cjs"],
+    capabilities: () => typescriptAdapter.capabilities(),
+    async parse(filePath, source) {
+        return parseTsJs(filePath, source, "javascript");
+    },
+};

package/dist/mcp/intelligence/handlers.d.ts

@@ -9,3 +9,8 @@ export declare function handleCodeHealthTool(rootInput: string): Promise<unknown
 export declare function handleArchitectureTool(rootInput: string): Promise<unknown>;
 export declare function handleKnowledgeTool(rootInput: string, args: Record<string, unknown>): Promise<unknown>;
 export declare function handlePolicyEvalTool(rootInput: string, args: Record<string, unknown>): Promise<unknown>;
+export declare function handleChangeAnalyzeTool(rootInput: string, args: Record<string, unknown>): Promise<unknown>;
+export declare function handleArchitectureCheckTool(rootInput: string): Promise<unknown>;
+export declare function handleProofInspectTool(rootInput: string, args: Record<string, unknown>): Promise<unknown>;
+export declare function handleEvidenceInspectTool(rootInput: string, args: Record<string, unknown>): Promise<unknown>;
+export declare function handleGraphQueryTool(rootInput: string, args: Record<string, unknown>): Promise<unknown>;