@praneeth_54/agentdoctor 2.0.0 → 2.1.0

package/dist/languages/go.js

@@ -0,0 +1,50 @@
+import { spawnSync } from "node:child_process";
+const GO_PROBE_TIMEOUT_MS = 5_000;
+/**
+ * Go toolchain bridge placeholder.
+ * Prefer real `go/ast` via `go run` when the Go toolchain is present; until an
+ * extractor is bundled, capability remains unsupported even if `go` exists.
+ * Today: always unsupported (no bundled extractor; avoids fake AST claims).
+ */
+export function goAvailable() {
+    const r = spawnSync("go", ["version"], {
+        encoding: "utf8",
+        timeout: GO_PROBE_TIMEOUT_MS,
+        windowsHide: true,
+    });
+    return r.status === 0 && !r.error;
+}
+export const goAdapter = {
+    id: "go",
+    extensions: [".go"],
+    capabilities: () => ({
+        parse: "unsupported",
+        symbols: "unsupported",
+        definitions: "unsupported",
+        references: "unsupported",
+        imports: "unsupported",
+        calls: "unsupported",
+        diagnostics: "unsupported",
+    }),
+    async parse(filePath, _source) {
+        const hasGo = goAvailable();
+        return {
+            language: "go",
+            file: filePath,
+            ok: false,
+            capabilities: goAdapter.capabilities(),
+            symbols: [],
+            imports: [],
+            calls: [],
+            diagnostics: [
+                hasGo
+                    ? "Go toolchain present but AgentDoctor go/ast extractor is not bundled yet"
+                    : "go not available on PATH",
+            ],
+            limitations: [
+                "Go AST requires a go/ast bridge or tree-sitter-go; not shipped in this package",
+                "Capability remains unsupported — no regex fallback under an AST claim",
+            ],
+        };
+    },
+};

package/dist/languages/index.d.ts

@@ -0,0 +1,11 @@
+import type { LanguageAdapter, ParseResult } from "./types.js";
+/** Languages with real AST backends today (or honest unsupported stubs). */
+export declare const languageAdapters: LanguageAdapter[];
+export declare function getAdapterForFile(filePath: string): LanguageAdapter | null;
+export declare function parseSourceFile(filePath: string, source: string): Promise<ParseResult>;
+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";
+export type { LanguageAdapter, ParseResult, LanguageId } from "./types.js";

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,8 @@
+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.
+ * Probe timeout skips hanging Windows Store / stub `php` binaries.
+ */
+export declare function phpAvailable(): boolean;
+export declare const phpAdapter: LanguageAdapter;

package/dist/languages/php.js

@@ -0,0 +1,202 @@
+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)}`;
+}
+const PHP_PROBE_TIMEOUT_MS = 5_000;
+const PHP_EXTRACT_TIMEOUT_MS = 15_000;
+/**
+ * Real PHP token extractor via `php -r` + token_get_all (requires `php` on PATH).
+ * Not regex. If php is missing, capabilities are unsupported.
+ * Probe timeout skips hanging Windows Store / stub `php` binaries.
+ */
+export function phpAvailable() {
+    const r = spawnSync("php", ["-r", "echo PHP_VERSION;"], {
+        encoding: "utf8",
+        timeout: PHP_PROBE_TIMEOUT_MS,
+        windowsHide: true,
+    });
+    return r.status === 0 && !r.error && 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,
+            timeout: PHP_EXTRACT_TIMEOUT_MS,
+            windowsHide: true,
+        });
+        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,11 @@
+import type { LanguageAdapter } from "./types.js";
+/**
+ * Resolve a working CPython binary, or null if none responds in time.
+ */
+export declare function resolvePythonBin(): string | null;
+/**
+ * Real Python AST via the CPython `ast` module (requires python on PATH).
+ * Not regex. If no interpreter is available, capabilities are unsupported.
+ */
+export declare function pythonAvailable(): boolean;
+export declare const pythonAdapter: LanguageAdapter;

package/dist/languages/python.js

@@ -0,0 +1,180 @@
+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)}`;
+}
+const PYTHON_PROBE_TIMEOUT_MS = 5_000;
+/**
+ * Prefer real interpreters; skip hanging Windows Store `python3` stubs via timeout.
+ */
+function pythonCandidates() {
+    return process.platform === "win32" ? ["python", "py", "python3"] : ["python3", "python"];
+}
+let cachedPythonBin;
+/**
+ * Resolve a working CPython binary, or null if none responds in time.
+ */
+export function resolvePythonBin() {
+    if (cachedPythonBin !== undefined)
+        return cachedPythonBin;
+    for (const bin of pythonCandidates()) {
+        const r = spawnSync(bin, ["-c", "import ast, json"], {
+            encoding: "utf8",
+            timeout: PYTHON_PROBE_TIMEOUT_MS,
+            windowsHide: true,
+        });
+        if (r.status === 0 && !r.error) {
+            cachedPythonBin = bin;
+            return bin;
+        }
+    }
+    cachedPythonBin = null;
+    return null;
+}
+/**
+ * Real Python AST via the CPython `ast` module (requires python on PATH).
+ * Not regex. If no interpreter is available, capabilities are unsupported.
+ */
+export function pythonAvailable() {
+    return resolvePythonBin() !== null;
+}
+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) {
+        const pythonBin = resolvePythonBin();
+        if (!pythonBin) {
+            return {
+                language: "python",
+                file: filePath,
+                ok: false,
+                capabilities: pythonAdapter.capabilities(),
+                symbols: [],
+                imports: [],
+                calls: [],
+                diagnostics: ["python not available on PATH"],
+                limitations: ["Python AST adapter requires python3/python with stdlib ast module"],
+            };
+        }
+        const r = spawnSync(pythonBin, ["-c", PY_EXTRACTOR, filePath], {
+            input: source,
+            encoding: "utf8",
+            maxBuffer: 8 * 1024 * 1024,
+            timeout: 15_000,
+            windowsHide: true,
+        });
+        if (r.status !== 0 || !r.stdout) {
+            return {
+                language: "python",
+                file: filePath,
+                ok: false,
+                capabilities: pythonAdapter.capabilities(),
+                symbols: [],
+                imports: [],
+                calls: [],
+                diagnostics: [r.stderr || r.error?.message || "python 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;