@praneeth_54/agentdoctor 1.1.1 → 2.0.1

package/dist/agents/aider/adapter.d.ts

@@ -0,0 +1 @@
+export { aiderAdapter, detectAider } from "./detector.js";

package/dist/agents/aider/adapter.js

@@ -0,0 +1 @@
+export { aiderAdapter, detectAider } from "./detector.js";

package/dist/agents/aider/detector.d.ts

@@ -0,0 +1,14 @@
+import type { AgentAdapter, AgentDetectionContext, AgentDetectionResult } from "../types.js";
+/**
+ * Aider project configuration detection.
+ *
+ * Official sources (aider.chat docs):
+ * - Config: `.aider.conf.yml` (cwd / git root); `.aider.conf.yaml` also seen in the wild
+ * - Ignore: `.aiderignore` (gitignore-style; default at git root)
+ * - Conventions: `CONVENTIONS.md` commonly loaded via conf `read:` — only counted when
+ *   an Aider config/ignore file is also present (avoids false positives)
+ *
+ * We do NOT inspect `~/.aider.conf.yml` — repository only.
+ */
+export declare function detectAider(context: AgentDetectionContext): Promise<AgentDetectionResult>;
+export declare const aiderAdapter: AgentAdapter;

package/dist/agents/aider/detector.js

@@ -0,0 +1,120 @@
+import { AGENT_DISPLAY_NAMES } from "../../constants.js";
+import { deriveStatus, inspectRepoFile, pathExistsInsideRoot, toAgentConfigFile, } from "../inspect.js";
+/**
+ * Aider project configuration detection.
+ *
+ * Official sources (aider.chat docs):
+ * - Config: `.aider.conf.yml` (cwd / git root); `.aider.conf.yaml` also seen in the wild
+ * - Ignore: `.aiderignore` (gitignore-style; default at git root)
+ * - Conventions: `CONVENTIONS.md` commonly loaded via conf `read:` — only counted when
+ *   an Aider config/ignore file is also present (avoids false positives)
+ *
+ * We do NOT inspect `~/.aider.conf.yml` — repository only.
+ */
+export async function detectAider(context) {
+    const { root, maxFileSizeBytes } = context;
+    const configFiles = [];
+    const diagnostics = [];
+    const seen = new Set();
+    const metadata = {
+        hasConf: false,
+        hasAiderignore: false,
+        hasConventions: false,
+    };
+    async function addFile(relativePath, kind) {
+        if (seen.has(relativePath)) {
+            return;
+        }
+        seen.add(relativePath);
+        const inspected = await inspectRepoFile(root, relativePath, maxFileSizeBytes);
+        configFiles.push(toAgentConfigFile(inspected, kind, {
+            legacy: false,
+            scope: "root",
+        }));
+        if (!inspected.exists) {
+            return;
+        }
+        if (!inspected.readable && inspected.error) {
+            diagnostics.push({
+                code: "aider/unreadable-file",
+                severity: "warning",
+                message: `Could not read Aider file: ${inspected.error}`,
+                file: relativePath,
+            });
+        }
+        else if (inspected.empty && kind !== "aider-ignore") {
+            diagnostics.push({
+                code: "aider/empty-config",
+                severity: "info",
+                message: "Aider config/instruction file is empty",
+                file: relativePath,
+            });
+        }
+    }
+    const confYml = await pathExistsInsideRoot(root, ".aider.conf.yml");
+    const confYaml = await pathExistsInsideRoot(root, ".aider.conf.yaml");
+    if (confYml) {
+        await addFile(".aider.conf.yml", "aider-conf");
+        metadata.hasConf = true;
+    }
+    else if (confYaml) {
+        await addFile(".aider.conf.yaml", "aider-conf");
+        metadata.hasConf = true;
+    }
+    if (await pathExistsInsideRoot(root, ".aiderignore")) {
+        await addFile(".aiderignore", "aider-ignore");
+        metadata.hasAiderignore = true;
+    }
+    const aiderPresent = Boolean(metadata.hasConf) || Boolean(metadata.hasAiderignore);
+    if (aiderPresent && (await pathExistsInsideRoot(root, "CONVENTIONS.md"))) {
+        await addFile("CONVENTIONS.md", "aider-conventions");
+        metadata.hasConventions = true;
+    }
+    const usable = configFiles.some((f) => f.readable &&
+        !f.empty &&
+        (f.kind === "aider-conf" || f.kind === "aider-conventions" || f.kind === "aider-ignore"));
+    const detected = aiderPresent;
+    const configured = usable || Boolean(metadata.hasAiderignore) || Boolean(metadata.hasConf);
+    const status = deriveStatus({
+        detected,
+        configured,
+        hasErrors: diagnostics.some((d) => d.severity === "error"),
+    });
+    const parts = [];
+    if (metadata.hasConf) {
+        parts.push("conf");
+    }
+    if (metadata.hasAiderignore) {
+        parts.push(".aiderignore");
+    }
+    if (metadata.hasConventions) {
+        parts.push("CONVENTIONS.md");
+    }
+    let summary;
+    if (!detected) {
+        summary = "not configured";
+    }
+    else if (configured) {
+        summary = parts.length > 0 ? parts.join(", ") : "configured";
+    }
+    else {
+        summary = "detected but not configured";
+    }
+    return {
+        id: "aider",
+        displayName: AGENT_DISPLAY_NAMES.aider,
+        detected,
+        configured,
+        status,
+        summary,
+        configFiles,
+        configPaths: configFiles.map((f) => f.relativePath),
+        diagnostics,
+        metadata,
+    };
+}
+export const aiderAdapter = {
+    id: "aider",
+    displayName: AGENT_DISPLAY_NAMES.aider,
+    detect: detectAider,
+};

package/dist/agents/copilot/adapter.d.ts

@@ -0,0 +1 @@
+export { copilotAdapter, detectCopilot } from "./detector.js";

package/dist/agents/copilot/adapter.js

@@ -0,0 +1 @@
+export { copilotAdapter, detectCopilot } from "./detector.js";

package/dist/agents/copilot/detector.d.ts

@@ -0,0 +1,13 @@
+import type { AgentAdapter, AgentDetectionContext, AgentDetectionResult } from "../types.js";
+/**
+ * GitHub Copilot project configuration detection.
+ *
+ * Official sources (docs.github.com Copilot custom instructions):
+ * - Repository-wide: `.github/copilot-instructions.md`
+ * - Path-specific: files under `.github/instructions/` ending in `.instructions.md`
+ *
+ * We do NOT inspect `~/.copilot` or user-global preference files — repository only.
+ * No official project-local deny/ignore file exists; Safe Fix does not invent one.
+ */
+export declare function detectCopilot(context: AgentDetectionContext): Promise<AgentDetectionResult>;
+export declare const copilotAdapter: AgentAdapter;

package/dist/agents/copilot/detector.js

@@ -0,0 +1,113 @@
+import { AGENT_DISPLAY_NAMES } from "../../constants.js";
+import { deriveStatus, inspectRepoFile, pathExistsInsideRoot, toAgentConfigFile, } from "../inspect.js";
+import { basenameOf } from "../types.js";
+/**
+ * GitHub Copilot project configuration detection.
+ *
+ * Official sources (docs.github.com Copilot custom instructions):
+ * - Repository-wide: `.github/copilot-instructions.md`
+ * - Path-specific: files under `.github/instructions/` ending in `.instructions.md`
+ *
+ * We do NOT inspect `~/.copilot` or user-global preference files — repository only.
+ * No official project-local deny/ignore file exists; Safe Fix does not invent one.
+ */
+export async function detectCopilot(context) {
+    const { root, discovery, maxFileSizeBytes } = context;
+    const configFiles = [];
+    const diagnostics = [];
+    const seen = new Set();
+    const metadata = {
+        repoInstructionsCount: 0,
+        pathInstructionsCount: 0,
+    };
+    async function addInstructionFile(relativePath, kind) {
+        if (seen.has(relativePath)) {
+            return;
+        }
+        seen.add(relativePath);
+        const inspected = await inspectRepoFile(root, relativePath, maxFileSizeBytes);
+        configFiles.push(toAgentConfigFile(inspected, kind, {
+            legacy: false,
+            scope: relativePath === ".github/copilot-instructions.md" ? "root" : "nested",
+        }));
+        if (kind === "copilot-instructions") {
+            metadata.repoInstructionsCount = Number(metadata.repoInstructionsCount) + 1;
+        }
+        else {
+            metadata.pathInstructionsCount = Number(metadata.pathInstructionsCount) + 1;
+        }
+        if (!inspected.exists) {
+            return;
+        }
+        if (!inspected.readable && inspected.error) {
+            diagnostics.push({
+                code: "copilot/unreadable-file",
+                severity: "warning",
+                message: `Could not read Copilot instruction file: ${inspected.error}`,
+                file: relativePath,
+            });
+        }
+        else if (inspected.empty) {
+            diagnostics.push({
+                code: "copilot/empty-instruction",
+                severity: "info",
+                message: "Copilot instruction file is empty",
+                file: relativePath,
+            });
+        }
+    }
+    if (await pathExistsInsideRoot(root, ".github/copilot-instructions.md")) {
+        await addInstructionFile(".github/copilot-instructions.md", "copilot-instructions");
+    }
+    for (const file of discovery.files) {
+        const relative = file.relativePath;
+        if (!relative.startsWith(".github/instructions/")) {
+            continue;
+        }
+        const base = basenameOf(relative);
+        if (!base.endsWith(".instructions.md")) {
+            continue;
+        }
+        await addInstructionFile(relative, "copilot-path-instructions");
+    }
+    const usableInstruction = configFiles.some((f) => f.readable && !f.empty);
+    const detected = Number(metadata.repoInstructionsCount) > 0 || Number(metadata.pathInstructionsCount) > 0;
+    const configured = usableInstruction;
+    const hasErrors = diagnostics.some((d) => d.severity === "error");
+    const status = deriveStatus({ detected, configured, hasErrors });
+    const parts = [];
+    if (Number(metadata.repoInstructionsCount) > 0) {
+        parts.push("copilot-instructions.md");
+    }
+    if (Number(metadata.pathInstructionsCount) > 0) {
+        const count = Number(metadata.pathInstructionsCount);
+        parts.push(`${count} path instruction${count === 1 ? "" : "s"}`);
+    }
+    let summary;
+    if (!detected) {
+        summary = "not configured";
+    }
+    else if (configured) {
+        summary = parts.length > 0 ? parts.join(", ") : "configured";
+    }
+    else {
+        summary = "detected but not configured";
+    }
+    return {
+        id: "copilot",
+        displayName: AGENT_DISPLAY_NAMES.copilot,
+        detected,
+        configured,
+        status,
+        summary,
+        configFiles,
+        configPaths: configFiles.map((f) => f.relativePath),
+        diagnostics,
+        metadata,
+    };
+}
+export const copilotAdapter = {
+    id: "copilot",
+    displayName: AGENT_DISPLAY_NAMES.copilot,
+    detect: detectCopilot,
+};

package/dist/agents/gemini/adapter.d.ts

@@ -0,0 +1 @@
+export { geminiCliAdapter, detectGeminiCli } from "./detector.js";

package/dist/agents/gemini/adapter.js

@@ -0,0 +1 @@
+export { geminiCliAdapter, detectGeminiCli } from "./detector.js";

package/dist/agents/gemini/detector.d.ts

@@ -0,0 +1,13 @@
+import type { AgentAdapter, AgentDetectionContext, AgentDetectionResult } from "../types.js";
+/**
+ * Gemini CLI project configuration detection.
+ *
+ * Official sources (google-gemini.github.io/gemini-cli):
+ * - Context: `GEMINI.md` (cwd, ancestors to git root, and subdirectories)
+ * - Project settings: `.gemini/settings.json`
+ * - Ignore: `.geminiignore` (gitignore-style)
+ *
+ * We do NOT inspect `~/.gemini` — repository only.
+ */
+export declare function detectGeminiCli(context: AgentDetectionContext): Promise<AgentDetectionResult>;
+export declare const geminiCliAdapter: AgentAdapter;

package/dist/agents/gemini/detector.js

@@ -0,0 +1,151 @@
+import { AGENT_DISPLAY_NAMES } from "../../constants.js";
+import { deriveStatus, inspectRepoFile, pathExistsInsideRoot, toAgentConfigFile, tryParseJson, } from "../inspect.js";
+import { basenameOf, isRootLevel } from "../types.js";
+/**
+ * Gemini CLI project configuration detection.
+ *
+ * Official sources (google-gemini.github.io/gemini-cli):
+ * - Context: `GEMINI.md` (cwd, ancestors to git root, and subdirectories)
+ * - Project settings: `.gemini/settings.json`
+ * - Ignore: `.geminiignore` (gitignore-style)
+ *
+ * We do NOT inspect `~/.gemini` — repository only.
+ */
+export async function detectGeminiCli(context) {
+    const { root, discovery, maxFileSizeBytes } = context;
+    const configFiles = [];
+    const diagnostics = [];
+    const seen = new Set();
+    const metadata = {
+        geminiMdCount: 0,
+        hasGeminiDir: false,
+        hasSettings: false,
+        hasGeminiignore: false,
+    };
+    async function addGeminiMd(relativePath) {
+        if (seen.has(relativePath)) {
+            return;
+        }
+        seen.add(relativePath);
+        const inspected = await inspectRepoFile(root, relativePath, maxFileSizeBytes);
+        configFiles.push(toAgentConfigFile(inspected, "gemini-md", {
+            legacy: false,
+            scope: isRootLevel(relativePath) ? "root" : "nested",
+        }));
+        metadata.geminiMdCount = Number(metadata.geminiMdCount) + 1;
+        if (!inspected.exists) {
+            return;
+        }
+        if (!inspected.readable && inspected.error) {
+            diagnostics.push({
+                code: "gemini/unreadable-file",
+                severity: "warning",
+                message: `Could not read Gemini context file: ${inspected.error}`,
+                file: relativePath,
+            });
+        }
+        else if (inspected.empty) {
+            diagnostics.push({
+                code: "gemini/empty-instruction",
+                severity: "info",
+                message: "Gemini context file is empty",
+                file: relativePath,
+            });
+        }
+    }
+    metadata.hasGeminiDir = await pathExistsInsideRoot(root, ".gemini");
+    if (await pathExistsInsideRoot(root, ".gemini/settings.json")) {
+        const relative = ".gemini/settings.json";
+        seen.add(relative);
+        const inspected = await inspectRepoFile(root, relative, maxFileSizeBytes);
+        let parseError;
+        if (inspected.readable && inspected.text !== null && !inspected.empty) {
+            const parsed = tryParseJson(inspected.text);
+            if (!parsed.ok) {
+                parseError = parsed.error;
+                diagnostics.push({
+                    code: "gemini/malformed-settings",
+                    severity: "warning",
+                    message: `${relative} could not be parsed: ${parsed.error}`,
+                    file: relative,
+                });
+            }
+        }
+        else if (inspected.exists && inspected.empty) {
+            diagnostics.push({
+                code: "gemini/empty-settings",
+                severity: "info",
+                message: `${relative} is empty`,
+                file: relative,
+            });
+        }
+        configFiles.push(toAgentConfigFile(inspected, "gemini-settings", {
+            legacy: false,
+            scope: "root",
+            ...(parseError !== undefined ? { parseError } : {}),
+        }));
+        metadata.hasSettings = true;
+    }
+    if (await pathExistsInsideRoot(root, ".geminiignore")) {
+        metadata.hasGeminiignore = true;
+    }
+    for (const file of discovery.files) {
+        if (basenameOf(file.relativePath) === "GEMINI.md") {
+            await addGeminiMd(file.relativePath);
+        }
+    }
+    if (await pathExistsInsideRoot(root, "GEMINI.md")) {
+        await addGeminiMd("GEMINI.md");
+    }
+    const usableInstruction = configFiles.some((f) => f.readable &&
+        !f.empty &&
+        (f.kind === "gemini-md" || (f.kind === "gemini-settings" && f.parseError === undefined)));
+    const detected = Boolean(metadata.hasGeminiDir) ||
+        Boolean(metadata.hasGeminiignore) ||
+        Number(metadata.geminiMdCount) > 0 ||
+        Boolean(metadata.hasSettings);
+    const configured = usableInstruction || Boolean(metadata.hasGeminiignore);
+    const hasParseProblems = configFiles.some((f) => f.parseError !== undefined);
+    const status = deriveStatus({
+        detected,
+        configured,
+        hasErrors: diagnostics.some((d) => d.severity === "error") || (hasParseProblems && !configured),
+    });
+    const parts = [];
+    if (Number(metadata.geminiMdCount) > 0) {
+        parts.push("GEMINI.md");
+    }
+    if (metadata.hasSettings) {
+        parts.push("settings");
+    }
+    if (metadata.hasGeminiignore) {
+        parts.push(".geminiignore");
+    }
+    let summary;
+    if (!detected) {
+        summary = "not configured";
+    }
+    else if (configured) {
+        summary = parts.length > 0 ? parts.join(", ") : "configured";
+    }
+    else {
+        summary = "detected but not configured";
+    }
+    return {
+        id: "gemini-cli",
+        displayName: AGENT_DISPLAY_NAMES["gemini-cli"],
+        detected,
+        configured,
+        status,
+        summary,
+        configFiles,
+        configPaths: configFiles.map((f) => f.relativePath),
+        diagnostics,
+        metadata,
+    };
+}
+export const geminiCliAdapter = {
+    id: "gemini-cli",
+    displayName: AGENT_DISPLAY_NAMES["gemini-cli"],
+    detect: detectGeminiCli,
+};

package/dist/agents/registry.js

@@ -1,11 +1,23 @@
+import { aiderAdapter } from "./aider/adapter.js";
 import { claudeAdapter } from "./claude/adapter.js";
 import { codexAdapter } from "./codex/adapter.js";
+import { copilotAdapter } from "./copilot/adapter.js";
+import { geminiCliAdapter } from "./gemini/adapter.js";
 import { cursorAdapter } from "./cursor/adapter.js";
+import { windsurfAdapter } from "./windsurf/adapter.js";
 /**
  * Central registry of AI coding agent adapters.
  * Add new agents by implementing AgentAdapter and appending here.
  */
-export const agentRegistry = [cursorAdapter, claudeAdapter, codexAdapter];
+export const agentRegistry = [
+    cursorAdapter,
+    claudeAdapter,
+    codexAdapter,
+    copilotAdapter,
+    windsurfAdapter,
+    geminiCliAdapter,
+    aiderAdapter,
+];
 export function getAgentAdapter(id) {
     return agentRegistry.find((adapter) => adapter.id === id);
 }

package/dist/agents/types.d.ts

@@ -1,6 +1,6 @@
 import type { AgentId, DiscoveredFile, DiscoveryResult } from "../types/index.js";
 export type AgentConfigStatus = "absent" | "detected" | "configured" | "misconfigured";
-export type AgentConfigFileKind = "cursor-rule-mdc" | "cursor-rule-ignored-md" | "cursor-legacy-cursorrules" | "agents-md" | "agents-override-md" | "claude-md" | "claude-local-md" | "claude-rule-md" | "claude-settings" | "claude-settings-local" | "codex-config" | "other";
+export type AgentConfigFileKind = "cursor-rule-mdc" | "cursor-rule-ignored-md" | "cursor-legacy-cursorrules" | "agents-md" | "agents-override-md" | "claude-md" | "claude-local-md" | "claude-rule-md" | "claude-settings" | "claude-settings-local" | "codex-config" | "copilot-instructions" | "copilot-path-instructions" | "windsurf-rule-md" | "windsurf-legacy-rules" | "gemini-md" | "gemini-settings" | "aider-conf" | "aider-ignore" | "aider-conventions" | "other";
 export type AgentConfigScope = "root" | "nested" | "legacy";
 export interface AgentConfigFile {
     relativePath: string;

package/dist/agents/windsurf/adapter.d.ts

@@ -0,0 +1 @@
+export { windsurfAdapter, detectWindsurf } from "./detector.js";

package/dist/agents/windsurf/adapter.js

@@ -0,0 +1 @@
+export { windsurfAdapter, detectWindsurf } from "./detector.js";

package/dist/agents/windsurf/detector.d.ts

@@ -0,0 +1,14 @@
+import type { AgentAdapter, AgentDetectionContext, AgentDetectionResult } from "../types.js";
+/**
+ * Windsurf / Cascade project rules detection.
+ *
+ * Official sources (docs.devin.ai Cascade memories & rules):
+ * - Preferred: `.devin/rules/*.md`
+ * - Fallback: `.windsurf/rules/*.md`
+ * - Legacy: `.windsurfrules` at workspace root
+ *
+ * We do NOT inspect `~/.codeium/windsurf` or OS system rules — repository only.
+ * No official project-local deny/ignore Fix writer; Safe Fix does not invent one.
+ */
+export declare function detectWindsurf(context: AgentDetectionContext): Promise<AgentDetectionResult>;
+export declare const windsurfAdapter: AgentAdapter;

package/dist/agents/windsurf/detector.js

@@ -0,0 +1,119 @@
+import { AGENT_DISPLAY_NAMES } from "../../constants.js";
+import { deriveStatus, inspectRepoFile, pathExistsInsideRoot, toAgentConfigFile, } from "../inspect.js";
+import { basenameOf } from "../types.js";
+/**
+ * Windsurf / Cascade project rules detection.
+ *
+ * Official sources (docs.devin.ai Cascade memories & rules):
+ * - Preferred: `.devin/rules/*.md`
+ * - Fallback: `.windsurf/rules/*.md`
+ * - Legacy: `.windsurfrules` at workspace root
+ *
+ * We do NOT inspect `~/.codeium/windsurf` or OS system rules — repository only.
+ * No official project-local deny/ignore Fix writer; Safe Fix does not invent one.
+ */
+export async function detectWindsurf(context) {
+    const { root, discovery, maxFileSizeBytes } = context;
+    const configFiles = [];
+    const diagnostics = [];
+    const seen = new Set();
+    const metadata = {
+        ruleCount: 0,
+        hasLegacyRules: false,
+        hasWindsurfDir: false,
+        hasDevinDir: false,
+    };
+    async function addRule(relativePath, kind, legacy) {
+        if (seen.has(relativePath)) {
+            return;
+        }
+        seen.add(relativePath);
+        const inspected = await inspectRepoFile(root, relativePath, maxFileSizeBytes);
+        configFiles.push(toAgentConfigFile(inspected, kind, {
+            legacy,
+            scope: relativePath === ".windsurfrules" ? "legacy" : "nested",
+        }));
+        metadata.ruleCount = Number(metadata.ruleCount) + 1;
+        if (legacy) {
+            metadata.hasLegacyRules = true;
+        }
+        if (!inspected.exists) {
+            return;
+        }
+        if (!inspected.readable && inspected.error) {
+            diagnostics.push({
+                code: "windsurf/unreadable-file",
+                severity: "warning",
+                message: `Could not read Windsurf rule file: ${inspected.error}`,
+                file: relativePath,
+            });
+        }
+        else if (inspected.empty) {
+            diagnostics.push({
+                code: "windsurf/empty-rule",
+                severity: "info",
+                message: "Windsurf rule file is empty",
+                file: relativePath,
+            });
+        }
+    }
+    metadata.hasWindsurfDir = await pathExistsInsideRoot(root, ".windsurf");
+    metadata.hasDevinDir = await pathExistsInsideRoot(root, ".devin");
+    if (await pathExistsInsideRoot(root, ".windsurfrules")) {
+        await addRule(".windsurfrules", "windsurf-legacy-rules", true);
+        diagnostics.push({
+            code: "windsurf/legacy-rules",
+            severity: "info",
+            message: "Legacy .windsurfrules detected; prefer .devin/rules/ or .windsurf/rules/",
+            file: ".windsurfrules",
+        });
+    }
+    for (const file of discovery.files) {
+        const relative = file.relativePath;
+        const base = basenameOf(relative);
+        if (!base.endsWith(".md")) {
+            continue;
+        }
+        if (relative.includes(".windsurf/rules/") || relative.includes(".devin/rules/")) {
+            await addRule(relative, "windsurf-rule-md", false);
+        }
+    }
+    const usable = configFiles.some((f) => f.readable && !f.empty);
+    const detected = Boolean(metadata.hasWindsurfDir) ||
+        Boolean(metadata.hasDevinDir) ||
+        Number(metadata.ruleCount) > 0;
+    const configured = usable;
+    const status = deriveStatus({
+        detected,
+        configured,
+        hasErrors: diagnostics.some((d) => d.severity === "error"),
+    });
+    let summary;
+    if (!detected) {
+        summary = "not configured";
+    }
+    else if (configured) {
+        const count = Number(metadata.ruleCount);
+        summary = `${count} rule${count === 1 ? "" : "s"}`;
+    }
+    else {
+        summary = "detected but not configured";
+    }
+    return {
+        id: "windsurf",
+        displayName: AGENT_DISPLAY_NAMES.windsurf,
+        detected,
+        configured,
+        status,
+        summary,
+        configFiles,
+        configPaths: configFiles.map((f) => f.relativePath),
+        diagnostics,
+        metadata,
+    };
+}
+export const windsurfAdapter = {
+    id: "windsurf",
+    displayName: AGENT_DISPLAY_NAMES.windsurf,
+    detect: detectWindsurf,
+};

package/dist/architecture/c4.d.ts

@@ -0,0 +1,22 @@
+import type { RepositoryGraph } from "../platform/types.js";
+export interface C4View {
+    level: "system-context" | "container" | "component" | "code";
+    title: string;
+    nodes: Array<{
+        id: string;
+        label: string;
+        kind: string;
+    }>;
+    edges: Array<{
+        from: string;
+        to: string;
+        kind: string;
+    }>;
+    evidenceKind: "observed" | "inferred" | "proposed";
+    limitations: string[];
+}
+/**
+ * C4-style views derived from repository graph evidence.
+ * Always labels inferred vs observed.
+ */
+export declare function buildC4Views(graph: RepositoryGraph): C4View[];