@praneeth_54/agentdoctor 1.1.0 → 2.0.0

package/dist/constants.d.ts

@@ -1,5 +1,6 @@
-export declare const PACKAGE_VERSION = "1.1.0";
+import type { AgentId } from "./types/index.js";
+export declare const PACKAGE_VERSION = "2.0.0";
 export declare const DEFAULT_MAX_FILE_SIZE_BYTES: number;
 /** Directories skipped during normal discovery (unless a rule needs them later). */
 export declare const DEFAULT_IGNORE_DIRECTORIES: Set<string>;
-export declare const AGENT_DISPLAY_NAMES: Record<"cursor" | "claude-code" | "codex", string>;
+export declare const AGENT_DISPLAY_NAMES: Record<AgentId, string>;

package/dist/constants.js

@@ -1,4 +1,4 @@
-export const PACKAGE_VERSION = "1.1.0";
+export const PACKAGE_VERSION = "2.0.0";
 export const DEFAULT_MAX_FILE_SIZE_BYTES = 2 * 1024 * 1024; // 2 MiB
 /** Directories skipped during normal discovery (unless a rule needs them later). */
 export const DEFAULT_IGNORE_DIRECTORIES = new Set([
@@ -35,4 +35,8 @@ export const AGENT_DISPLAY_NAMES = {
     cursor: "Cursor",
     "claude-code": "Claude Code",
     codex: "Codex",
+    copilot: "GitHub Copilot",
+    windsurf: "Windsurf",
+    "gemini-cli": "Gemini CLI",
+    aider: "Aider",
 };

package/dist/contracts/adapters.d.ts

@@ -0,0 +1,7 @@
+import type { FindingContract, GraphEdgeContract } from "./index.js";
+import type { PlatformFinding, GraphEdge } from "../platform/types.js";
+export declare function platformFindingToContract(finding: PlatformFinding, opts?: {
+    repositoryId?: string;
+    snapshotId?: string;
+}): FindingContract;
+export declare function platformEdgeToContract(edge: GraphEdge): GraphEdgeContract;

package/dist/contracts/adapters.js

@@ -0,0 +1,60 @@
+import { CONTRACTS_VERSION, clampConfidence } from "./index.js";
+function mapKind(kind) {
+    if (kind === "verified")
+        return "observed";
+    if (kind === "inferred")
+        return "inferred";
+    return "unknown";
+}
+export function platformFindingToContract(finding, opts) {
+    return {
+        id: finding.id,
+        module: finding.module,
+        severity: finding.severity,
+        title: finding.title,
+        message: finding.message,
+        recommendation: finding.recommendation,
+        confidence: clampConfidence(finding.confidence),
+        evidence: finding.evidence.map((e, i) => ({
+            id: `${finding.id}_ev_${i}`,
+            kind: mapKind(e.kind),
+            detail: e.detail,
+            ...(e.path
+                ? {
+                    location: {
+                        path: e.path,
+                        ...(typeof e.line === "number" ? { startLine: e.line } : {}),
+                    },
+                }
+                : {}),
+            ...(opts?.snapshotId ? { snapshotId: opts.snapshotId } : {}),
+        })),
+        analysisVersion: CONTRACTS_VERSION,
+        timestamp: new Date().toISOString(),
+        ...(opts?.repositoryId ? { repositoryId: opts.repositoryId } : {}),
+        ...(opts?.snapshotId ? { snapshotId: opts.snapshotId } : {}),
+        ...(finding.falsePositiveWarning
+            ? {
+                falsePositiveWarning: finding.falsePositiveWarning,
+                limitations: [finding.falsePositiveWarning],
+            }
+            : {}),
+    };
+}
+export function platformEdgeToContract(edge) {
+    return {
+        id: edge.id,
+        from: edge.from,
+        to: edge.to,
+        kind: edge.kind,
+        evidence: [
+            {
+                id: `${edge.id}_ev`,
+                kind: mapKind(edge.evidence),
+                detail: `edge kind=${edge.kind}`,
+            },
+        ],
+        confidence: edge.evidence === "verified" ? 0.85 : edge.evidence === "inferred" ? 0.5 : 0.2,
+        analysisVersion: CONTRACTS_VERSION,
+    };
+}

package/dist/contracts/index.d.ts

@@ -0,0 +1,162 @@
+/**
+ * AgentDoctor 2.0 shared core contracts.
+ * Unifies Safety / Brain / Platform without breaking existing module types.
+ */
+export declare const CONTRACTS_VERSION: "2.0.0-contracts";
+export type Confidence = number;
+export type EpistemicKind = "observed" | "inferred" | "proposed" | "unknown";
+export type Severity = "critical" | "high" | "medium" | "low" | "info";
+export interface SourceLocation {
+    path: string;
+    startLine?: number;
+    endLine?: number;
+    startColumn?: number;
+    endColumn?: number;
+}
+export interface EvidenceRef {
+    id: string;
+    kind: EpistemicKind;
+    detail: string;
+    location?: SourceLocation;
+    snapshotId?: string;
+    redacted?: boolean;
+}
+export interface ProvenanceRef {
+    id: string;
+    repositoryId: string;
+    snapshotId?: string;
+    commit?: string | null;
+    branch?: string | null;
+    agentId?: string | null;
+    model?: string | null;
+    analysisVersion: string;
+    recordedAt: string;
+    fields: Record<string, {
+        value: string | null;
+        kind: EpistemicKind;
+    }>;
+}
+export interface GraphNodeContract {
+    id: string;
+    kind: string;
+    label: string;
+    path?: string;
+    meta?: Record<string, string | number | boolean>;
+}
+export interface GraphEdgeContract {
+    id: string;
+    from: string;
+    to: string;
+    kind: string;
+    evidence: EvidenceRef[];
+    confidence: Confidence;
+    analysisVersion: string;
+    sourceLocation?: SourceLocation;
+}
+export interface FindingContract {
+    id: string;
+    module: string;
+    severity: Severity;
+    title: string;
+    message: string;
+    recommendation: string;
+    confidence: Confidence;
+    evidence: EvidenceRef[];
+    location?: SourceLocation;
+    repositoryId?: string;
+    snapshotId?: string;
+    analysisVersion: string;
+    timestamp: string;
+    limitations?: string[];
+    falsePositiveWarning?: string;
+}
+export type KnowledgeStatus = "observed" | "proposed" | "draft" | "pending-review" | "approved" | "rejected" | "deprecated" | "unknown";
+export interface KnowledgeRecordContract {
+    id: string;
+    title: string;
+    content: string;
+    status: KnowledgeStatus;
+    owner?: string | null;
+    approver?: string | null;
+    audience?: string[];
+    version: string;
+    effectiveAt?: string | null;
+    expiresAt?: string | null;
+    source?: string;
+    evidence: EvidenceRef[];
+    relatedRepositoryId?: string;
+    relatedModule?: string;
+    relatedPolicyId?: string;
+    changeHistory: Array<{
+        at: string;
+        by?: string;
+        note: string;
+        from?: KnowledgeStatus;
+        to?: KnowledgeStatus;
+    }>;
+}
+export type PolicyDecisionKind = "allow" | "block" | "require-approval" | "sandbox-only" | "deny-network" | "deny-secrets";
+export interface PolicyDecisionContract {
+    actionId: string;
+    decision: PolicyDecisionKind;
+    reason: string;
+    policyId?: string;
+    policyVersion: string;
+    inputClassification: string;
+    evidence: EvidenceRef[];
+    riskLevel: Severity;
+    executionStatus: "not-executed" | "executed" | "blocked-by-enforcement";
+    approvalStatus: "not-required" | "pending" | "approved" | "denied";
+    timestamp: string;
+}
+export interface AgentEventContract {
+    id: string;
+    sessionId: string;
+    timestamp: string;
+    type: string;
+    summary: string;
+    detail?: Record<string, string>;
+    risk?: Severity | "none";
+}
+export interface OwnershipContract {
+    path: string;
+    owners: string[];
+    kind: EpistemicKind;
+    evidence: EvidenceRef[];
+}
+export interface RepositoryIdentity {
+    id: string;
+    root: string;
+    name?: string;
+}
+export interface WorkspaceIdentity {
+    id: string;
+    name: string;
+    repositoryIds: string[];
+}
+export interface SnapshotContract {
+    id: string;
+    repositoryId: string;
+    createdAt: string;
+    kind: "brain" | "platform" | "graph" | "workspace";
+    analysisVersion: string;
+    limitations: string[];
+}
+export interface StorageProvider {
+    readonly kind: "filesystem" | "sqlite" | "postgres" | "memory";
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    list(prefix: string): Promise<string[]>;
+}
+/** Feature flags for experimental AgentDoctor 2.0 capabilities. */
+export interface FeatureFlags {
+    typescriptAst: boolean;
+    sqliteStorage: boolean;
+    teamMode: boolean;
+    enforcementRunner: boolean;
+    vectorSearch: boolean;
+    architectureC4: boolean;
+}
+export declare const DEFAULT_FEATURE_FLAGS: FeatureFlags;
+export declare function clampConfidence(value: number): Confidence;

package/dist/contracts/index.js

@@ -0,0 +1,18 @@
+/**
+ * AgentDoctor 2.0 shared core contracts.
+ * Unifies Safety / Brain / Platform without breaking existing module types.
+ */
+export const CONTRACTS_VERSION = "2.0.0-contracts";
+export const DEFAULT_FEATURE_FLAGS = {
+    typescriptAst: true,
+    sqliteStorage: false,
+    teamMode: false,
+    enforcementRunner: false,
+    vectorSearch: false,
+    architectureC4: true,
+};
+export function clampConfidence(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.max(0, Math.min(1, value));
+}

package/dist/core/baseline/store.d.ts

@@ -0,0 +1,48 @@
+import type { Finding, ScanResult } from "../../types/index.js";
+export interface NamedBaseline {
+    name: string;
+    createdAt: string;
+    root: string;
+    findingIds: string[];
+    findingFingerprints: string[];
+    counts: {
+        total: number;
+        critical: number;
+        warning: number;
+        info: number;
+    };
+}
+export declare function fingerprintFinding(finding: Finding): string;
+export declare function baselineFromScan(name: string, scan: ScanResult): NamedBaseline;
+export declare function saveNamedBaseline(rootInput: string, baseline: NamedBaseline): Promise<string>;
+export declare function loadNamedBaseline(rootInput: string, name: string): Promise<NamedBaseline | null>;
+export declare function listNamedBaselines(rootInput: string): Promise<string[]>;
+export declare function deleteNamedBaseline(rootInput: string, name: string): Promise<void>;
+export interface BaselineDiff {
+    name: string;
+    /** New findings vs baseline (fingerprints) */
+    added: string[];
+    /** Resolved findings vs baseline */
+    removed: string[];
+    /** Recurring / unchanged fingerprints */
+    recurring: string[];
+    unchanged: number;
+}
+export declare function compareToBaseline(baseline: NamedBaseline, findings: Finding[]): BaselineDiff;
+export interface BaselineTrendPoint {
+    name: string;
+    createdAt: string;
+    counts: NamedBaseline["counts"];
+}
+export interface BaselineTrends {
+    root: string;
+    points: BaselineTrendPoint[];
+    /** Count deltas between chronologically adjacent baselines (no causality claimed). */
+    deltas: Array<{
+        from: string;
+        to: string;
+        totalDelta: number;
+        criticalDelta: number;
+    }>;
+}
+export declare function computeBaselineTrends(rootInput: string): Promise<BaselineTrends>;

package/dist/core/baseline/store.js

@@ -0,0 +1,163 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { atomicWriteTextFile } from "../../utils/fs.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+function baselineDir(root) {
+    return path.join(root, ".agentdoctor", "baselines");
+}
+function safeBaselineName(name) {
+    const safe = name.replace(/[^a-zA-Z0-9._-]/g, "_");
+    if (!safe || safe === "." || safe === "..") {
+        throw new Error("invalid baseline name");
+    }
+    return safe;
+}
+export function fingerprintFinding(finding) {
+    return [finding.ruleId, finding.severity, finding.evidence?.path ?? "", finding.title].join("|");
+}
+function isNamedBaseline(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const b = value;
+    return (typeof b.name === "string" &&
+        typeof b.createdAt === "string" &&
+        typeof b.root === "string" &&
+        Array.isArray(b.findingIds) &&
+        Array.isArray(b.findingFingerprints) &&
+        typeof b.counts === "object" &&
+        b.counts !== null);
+}
+export function baselineFromScan(name, scan) {
+    const fingerprints = scan.findings.map(fingerprintFinding).sort();
+    return {
+        name,
+        createdAt: new Date().toISOString(),
+        root: scan.repository.root,
+        findingIds: scan.findings.map((f) => f.id).sort(),
+        findingFingerprints: fingerprints,
+        counts: {
+            total: scan.findings.length,
+            critical: scan.findings.filter((f) => f.severity === "critical").length,
+            warning: scan.findings.filter((f) => f.severity === "warning").length,
+            info: scan.findings.filter((f) => f.severity === "info").length,
+        },
+    };
+}
+export async function saveNamedBaseline(rootInput, baseline) {
+    const root = resolveRepoRoot(rootInput);
+    const safeName = safeBaselineName(baseline.name);
+    const dir = baselineDir(root);
+    await fs.mkdir(dir, { recursive: true });
+    const file = path.join(dir, `${safeName}.json`);
+    await atomicWriteTextFile(file, `${JSON.stringify(baseline, null, 2)}\n`);
+    return file;
+}
+export async function loadNamedBaseline(rootInput, name) {
+    const root = resolveRepoRoot(rootInput);
+    const safeName = safeBaselineName(name);
+    try {
+        const raw = await fs.readFile(path.join(baselineDir(root), `${safeName}.json`), "utf8");
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            throw new Error(`corrupt baseline JSON: ${safeName}`);
+        }
+        if (!isNamedBaseline(parsed)) {
+            throw new Error(`corrupt baseline schema: ${safeName}`);
+        }
+        return parsed;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+export async function listNamedBaselines(rootInput) {
+    const root = resolveRepoRoot(rootInput);
+    try {
+        const names = await fs.readdir(baselineDir(root));
+        return names
+            .filter((n) => n.endsWith(".json"))
+            .map((n) => n.replace(/\.json$/, ""))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+export async function deleteNamedBaseline(rootInput, name) {
+    const root = resolveRepoRoot(rootInput);
+    const safeName = safeBaselineName(name);
+    const file = path.join(baselineDir(root), `${safeName}.json`);
+    try {
+        await fs.unlink(file);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT") {
+            throw new Error(`baseline not found: ${name}`);
+        }
+        throw error;
+    }
+}
+export function compareToBaseline(baseline, findings) {
+    const current = new Set(findings.map(fingerprintFinding));
+    const previous = new Set(baseline.findingFingerprints);
+    const added = [];
+    const removed = [];
+    const recurring = [];
+    for (const fp of current) {
+        if (!previous.has(fp))
+            added.push(fp);
+        else
+            recurring.push(fp);
+    }
+    for (const fp of previous) {
+        if (!current.has(fp))
+            removed.push(fp);
+    }
+    return {
+        name: baseline.name,
+        added: added.sort(),
+        removed: removed.sort(),
+        recurring: recurring.sort(),
+        unchanged: recurring.length,
+    };
+}
+export async function computeBaselineTrends(rootInput) {
+    const root = resolveRepoRoot(rootInput);
+    const names = await listNamedBaselines(root);
+    const points = [];
+    for (const name of names) {
+        try {
+            const baseline = await loadNamedBaseline(root, name);
+            if (!baseline)
+                continue;
+            points.push({
+                name: baseline.name,
+                createdAt: baseline.createdAt,
+                counts: baseline.counts,
+            });
+        }
+        catch {
+            // skip corrupt for trends listing; load errors already fail-closed elsewhere
+        }
+    }
+    points.sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.name.localeCompare(b.name));
+    const deltas = [];
+    for (let i = 1; i < points.length; i += 1) {
+        const prev = points[i - 1];
+        const next = points[i];
+        deltas.push({
+            from: prev.name,
+            to: next.name,
+            totalDelta: next.counts.total - prev.counts.total,
+            criticalDelta: next.counts.critical - prev.counts.critical,
+        });
+    }
+    return { root, points, deltas };
+}

package/dist/core/brain-cli/service.d.ts

@@ -0,0 +1,26 @@
+import { type ProjectBrain, type SnapshotMeta } from "../understanding/brain/index.js";
+export interface BrainStatus {
+    root: string;
+    storeRoot: string;
+    hasSnapshot: boolean;
+    latestSnapshotId: string | null;
+    snapshotCount: number;
+    projectName: string | null;
+    schemaVersion: string | null;
+}
+export interface BrainSearchHit {
+    kind: "claim" | "component" | "unknown" | "limitation";
+    id: string;
+    text: string;
+    score: number;
+}
+export declare function getBrainStatus(root: string): Promise<BrainStatus>;
+export declare function initBrainStore(root: string): Promise<BrainStatus>;
+export declare function loadLatestBrain(root: string): Promise<ProjectBrain | null>;
+export declare function rebuildBrain(root: string): Promise<ProjectBrain>;
+export declare function listBrainSnapshots(root: string): Promise<SnapshotMeta[]>;
+export declare function showBrainSnapshot(root: string, snapshotId: string): Promise<ProjectBrain>;
+export declare function searchBrain(brain: ProjectBrain, query: string): BrainSearchHit[];
+export declare function exportBrain(root: string, outputPath: string, snapshotId?: string): Promise<string>;
+export declare function importBrain(root: string, inputPath: string): Promise<SnapshotMeta>;
+export declare function inspectBrainSummary(root: string): Promise<Record<string, unknown>>;

package/dist/core/brain-cli/service.js

@@ -0,0 +1,175 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { LocalBrainStore, createBrainQueryEngine, redactBrainForStorage, } from "../understanding/brain/index.js";
+import { compileProjectBrain } from "../../mcp/brain/compile.js";
+import { resolveRepoRoot } from "../../utils/path.js";
+import { isDirectory } from "../../utils/fs.js";
+function storeFor(root) {
+    return LocalBrainStore.underRepo(resolveRepoRoot(root));
+}
+export async function getBrainStatus(root) {
+    const resolved = resolveRepoRoot(root);
+    if (!(await isDirectory(resolved))) {
+        throw new Error(`not a directory: ${resolved}`);
+    }
+    const store = storeFor(resolved);
+    const storeRoot = path.join(resolved, ".agentdoctor", "project-brain");
+    try {
+        const meta = await store.readMeta();
+        return {
+            root: resolved,
+            storeRoot,
+            hasSnapshot: meta.latestSnapshotId !== null,
+            latestSnapshotId: meta.latestSnapshotId,
+            snapshotCount: meta.snapshots.length,
+            projectName: meta.projectName || null,
+            schemaVersion: meta.schemaVersion || null,
+        };
+    }
+    catch {
+        return {
+            root: resolved,
+            storeRoot,
+            hasSnapshot: false,
+            latestSnapshotId: null,
+            snapshotCount: 0,
+            projectName: null,
+            schemaVersion: null,
+        };
+    }
+}
+export async function initBrainStore(root) {
+    const resolved = resolveRepoRoot(root);
+    const store = storeFor(resolved);
+    await store.ensureRoot();
+    return getBrainStatus(resolved);
+}
+export async function loadLatestBrain(root) {
+    const store = storeFor(root);
+    try {
+        const brain = await store.loadLatest();
+        return brain ? redactBrainForStorage(brain) : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function rebuildBrain(root) {
+    const resolved = resolveRepoRoot(root);
+    const store = storeFor(resolved);
+    let previous = null;
+    try {
+        previous = await store.loadLatest();
+    }
+    catch {
+        previous = null;
+    }
+    const brain = await compileProjectBrain(resolved, {
+        ...(previous ? { previousClaims: previous.claims } : {}),
+    });
+    try {
+        await store.saveSnapshot(brain);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (!/refusing overwrite/i.test(message)) {
+            throw error;
+        }
+    }
+    return redactBrainForStorage(brain);
+}
+export async function listBrainSnapshots(root) {
+    const store = storeFor(root);
+    try {
+        return await store.listSnapshots();
+    }
+    catch {
+        return [];
+    }
+}
+export async function showBrainSnapshot(root, snapshotId) {
+    const store = storeFor(root);
+    const brain = await store.loadSnapshot(snapshotId);
+    return redactBrainForStorage(brain);
+}
+export function searchBrain(brain, query) {
+    const q = query.trim().toLowerCase();
+    if (!q) {
+        return [];
+    }
+    const hits = [];
+    for (const claim of brain.claims) {
+        const text = `${claim.subject} ${claim.predicate} ${claim.object}`;
+        if (text.toLowerCase().includes(q)) {
+            hits.push({ kind: "claim", id: claim.id, text: text.slice(0, 240), score: 1 });
+        }
+    }
+    for (const component of brain.components) {
+        const text = `${component.id} ${component.name ?? ""} ${component.type}`;
+        if (text.toLowerCase().includes(q)) {
+            hits.push({ kind: "component", id: component.id, text: text.slice(0, 240), score: 1 });
+        }
+    }
+    for (const [i, unknown] of brain.unknowns.entries()) {
+        if (unknown.toLowerCase().includes(q)) {
+            hits.push({ kind: "unknown", id: `unknown-${i}`, text: unknown.slice(0, 240), score: 0.5 });
+        }
+    }
+    for (const [i, limitation] of brain.limitations.entries()) {
+        if (limitation.toLowerCase().includes(q)) {
+            hits.push({
+                kind: "limitation",
+                id: `limitation-${i}`,
+                text: limitation.slice(0, 240),
+                score: 0.5,
+            });
+        }
+    }
+    return hits.sort((a, b) => b.score - a.score || a.id.localeCompare(b.id));
+}
+export async function exportBrain(root, outputPath, snapshotId) {
+    const store = storeFor(root);
+    const brain = snapshotId ? await store.loadSnapshot(snapshotId) : await store.loadLatest();
+    if (!brain) {
+        throw new Error("no Project Brain snapshot to export; run agentdoctor brain rebuild");
+    }
+    const safe = redactBrainForStorage(brain);
+    const absolute = path.resolve(outputPath);
+    await fs.mkdir(path.dirname(absolute), { recursive: true });
+    await fs.writeFile(absolute, `${JSON.stringify(safe, null, 2)}\n`, "utf8");
+    return absolute;
+}
+export async function importBrain(root, inputPath) {
+    const absolute = path.resolve(inputPath);
+    const raw = await fs.readFile(absolute, "utf8");
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`import file is not valid JSON: ${absolute}`);
+    }
+    if (!parsed || typeof parsed !== "object") {
+        throw new Error("import JSON must be an object");
+    }
+    const store = storeFor(root);
+    // saveSnapshot redacts and validates via serialize path
+    return store.saveSnapshot(parsed);
+}
+export async function inspectBrainSummary(root) {
+    let brain = await loadLatestBrain(root);
+    if (!brain) {
+        brain = await rebuildBrain(root);
+    }
+    const engine = createBrainQueryEngine(brain);
+    const summary = engine.execute({ type: "ProjectSummary" });
+    return {
+        snapshotId: brain.snapshot.id,
+        projectName: brain.metadata.projectName,
+        claimCount: brain.claims.length,
+        componentCount: brain.components.length,
+        riskCount: brain.risks.risks.length,
+        unknownCount: brain.unknowns.length,
+        summary: summary.result,
+    };
+}