@praneeth_54/agentdoctor 1.1.0 → 2.0.0

package/dist/reporters/terminal/report.js

@@ -7,7 +7,39 @@ import { formatPackageManager, formatPackageManagers } from "../../detectors/pac
 import { colors, symbolFail, symbolInfo, symbolOk, symbolWarn } from "../../utils/colors.js";
 import { sanitizeTerminalText } from "../../security/redaction.js";
 const DEFAULT_FINDING_LIMIT = 12;
-const LIMITED_ANALYSIS_NOTE = "No supported coding-agent configuration detected; agent-specific security exposure checks are limited.";
+const LIMITED_ANALYSIS_NOTE = "Agent-specific exposure checks are limited (no supported agent config); repository hygiene still applied.";
+/** Agents with an implemented Safe Fix writer (detect-only agents are excluded). */
+const SAFE_FIX_AGENT_IDS = new Set([
+    "cursor",
+    "claude-code",
+    "codex",
+    "gemini-cli",
+    "aider",
+]);
+function renderAgentCoverageSummary(result) {
+    const configured = result.agents.filter((a) => a.configured);
+    const detectedOnly = result.agents.filter((a) => a.detected && !a.configured);
+    const withFix = configured.filter((a) => SAFE_FIX_AGENT_IDS.has(a.id));
+    const detectOnlyConfigured = configured.filter((a) => !SAFE_FIX_AGENT_IDS.has(a.id));
+    const lines = [];
+    lines.push("");
+    if (result.agentSecurityAnalysis === "limited") {
+        lines.push(colors.dim("  Coverage: 0 configured · universal hygiene still runs (limited agent analysis)"));
+        return lines;
+    }
+    const parts = [`${configured.length} configured`];
+    if (detectedOnly.length > 0) {
+        parts.push(`${detectedOnly.length} detected-only`);
+    }
+    if (withFix.length > 0) {
+        parts.push(`Safe Fix: ${withFix.map((a) => a.displayName).join(", ")}`);
+    }
+    if (detectOnlyConfigured.length > 0) {
+        parts.push(`detect-only (no Safe Fix writer): ${detectOnlyConfigured.map((a) => a.displayName).join(", ")}`);
+    }
+    lines.push(colors.dim(`  Coverage: ${parts.join(" · ")}`));
+    return lines;
+}
 function groupFindings(findings) {
     return {
         critical: findings.filter((f) => f.severity === "critical"),
@@ -152,6 +184,7 @@ export function renderTerminalReport(result, options = {}) {
             }
         }
     }
+    lines.push(...renderAgentCoverageSummary(result));
     lines.push("");
     const grouped = groupFindings(result.findings);
     const total = result.summary.total;
@@ -164,10 +197,10 @@ export function renderTerminalReport(result, options = {}) {
     }
     if (total === 0) {
         if (limited) {
-            lines.push(`  ${symbolWarn()} Nothing to audit yet — no Cursor, Claude Code, or Codex config found`);
+            lines.push(`  ${symbolOk()} No repository-hygiene findings — agent readiness not scored (no supported agent config)`);
             lines.push("");
-            lines.push(colors.dim("  Next: add project agent config (for example `.cursor/`, `CLAUDE.md` / `.claude/`, or `AGENTS.md`),"));
-            lines.push(colors.dim("  then re-run `agentdoctor` in this repository."));
+            lines.push(colors.dim("  Optional next: add project agent config (`.cursor/`, `CLAUDE.md`, `AGENTS.md`, `.github/copilot-instructions.md`, `.windsurf/rules/`, `GEMINI.md`, or `.aider.conf.yml`)"));
+            lines.push(colors.dim("  so agent exposure checks run fully. CLI, Action, and Project Brain MCP still work without an agent."));
         }
         else {
             lines.push(`  ${symbolOk()} No findings`);
@@ -217,7 +250,7 @@ export function renderTerminalReport(result, options = {}) {
     lines.push("");
     if (result.scoringAvailable && result.scores) {
         if (limited) {
-            lines.push(`  Readiness: n/a — configure Cursor, Claude Code, or Codex before treating scores as agent readiness`);
+            lines.push(`  Readiness: n/a — configure a supported agent (Cursor, Claude Code, Codex, Copilot, Windsurf, Gemini CLI, or Aider) before treating scores as agent readiness`);
             lines.push(colors.dim(`  Numeric scores remain in JSON (overall ${result.scores.overall}/100) for repository-risk findings only`));
         }
         else {

package/dist/storage/provider.d.ts

@@ -0,0 +1,35 @@
+import type { StorageProvider } from "../contracts/index.js";
+export declare class FilesystemStorageProvider implements StorageProvider {
+    readonly kind: "filesystem";
+    private readonly root;
+    constructor(rootInput: string, subdir?: string);
+    private resolveKey;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    list(prefix: string): Promise<string[]>;
+}
+/** In-memory provider for tests and optional ephemeral mode. */
+export declare class MemoryStorageProvider implements StorageProvider {
+    readonly kind: "memory";
+    private readonly map;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    list(prefix: string): Promise<string[]>;
+}
+/**
+ * SQLite provider — optional. Requires better-sqlite3 when enabled.
+ * Without the dependency, construction throws a documented error (no fake DB).
+ */
+export declare function tryCreateSqliteStorage(_root: string): Promise<StorageProvider | {
+    error: string;
+}>;
+export interface WorkspaceRecord {
+    id: string;
+    name: string;
+    repositoryRoots: string[];
+    createdAt: string;
+}
+export declare function saveWorkspace(storage: StorageProvider, workspace: WorkspaceRecord): Promise<void>;
+export declare function loadWorkspace(storage: StorageProvider, id: string): Promise<WorkspaceRecord | null>;

package/dist/storage/provider.js

@@ -0,0 +1,103 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { resolveRepoRoot, isPathInsideRoot } from "../utils/path.js";
+import { atomicWriteTextFile } from "../utils/fs.js";
+export class FilesystemStorageProvider {
+    kind = "filesystem";
+    root;
+    constructor(rootInput, subdir = ".agentdoctor/storage") {
+        this.root = path.join(resolveRepoRoot(rootInput), subdir);
+    }
+    resolveKey(key) {
+        if (key.includes("\0") || key.split(/[/\\]/).includes("..") || path.isAbsolute(key)) {
+            throw new Error(`unsafe storage key: ${key}`);
+        }
+        const target = path.resolve(this.root, key);
+        if (!isPathInsideRoot(this.root, target))
+            throw new Error("storage path escape");
+        return target;
+    }
+    async get(key) {
+        try {
+            return await fs.readFile(this.resolveKey(key), "utf8");
+        }
+        catch {
+            return null;
+        }
+    }
+    async set(key, value) {
+        const target = this.resolveKey(key);
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        await atomicWriteTextFile(target, value);
+    }
+    async delete(key) {
+        try {
+            await fs.unlink(this.resolveKey(key));
+        }
+        catch {
+            // ignore
+        }
+    }
+    async list(prefix) {
+        const base = this.resolveKey(prefix || ".");
+        const out = [];
+        async function walk(dir, rel) {
+            let entries;
+            try {
+                entries = await fs.readdir(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const e of entries) {
+                const nextRel = rel ? `${rel}/${e.name}` : e.name;
+                if (e.isDirectory())
+                    await walk(path.join(dir, e.name), nextRel);
+                else
+                    out.push(nextRel);
+            }
+        }
+        const st = await fs.stat(base).catch(() => null);
+        if (!st)
+            return [];
+        if (st.isFile())
+            return [prefix];
+        await walk(base, prefix === "." ? "" : prefix);
+        return out.sort();
+    }
+}
+/** In-memory provider for tests and optional ephemeral mode. */
+export class MemoryStorageProvider {
+    kind = "memory";
+    map = new Map();
+    async get(key) {
+        return this.map.get(key) ?? null;
+    }
+    async set(key, value) {
+        this.map.set(key, value);
+    }
+    async delete(key) {
+        this.map.delete(key);
+    }
+    async list(prefix) {
+        return [...this.map.keys()].filter((k) => k.startsWith(prefix)).sort();
+    }
+}
+/**
+ * SQLite provider — optional. Requires better-sqlite3 when enabled.
+ * Without the dependency, construction throws a documented error (no fake DB).
+ */
+export async function tryCreateSqliteStorage(_root) {
+    return {
+        error: "SQLite storage is feature-flagged and requires optional dependency better-sqlite3 (not bundled). Use filesystem provider for local-first default.",
+    };
+}
+export async function saveWorkspace(storage, workspace) {
+    await storage.set(`workspaces/${workspace.id}.json`, `${JSON.stringify(workspace, null, 2)}\n`);
+}
+export async function loadWorkspace(storage, id) {
+    const raw = await storage.get(`workspaces/${id}.json`);
+    if (!raw)
+        return null;
+    return JSON.parse(raw);
+}

package/dist/team/auth.d.ts

@@ -0,0 +1,35 @@
+import type { StorageProvider } from "../contracts/index.js";
+export type TeamRole = "owner" | "admin" | "member" | "viewer";
+export interface TeamUser {
+    id: string;
+    username: string;
+    passwordHash: string;
+    salt: string;
+    role: TeamRole;
+    createdAt: string;
+    /** Development-only local auth — not enterprise SSO. */
+    authMode: "local-dev";
+}
+export interface SessionToken {
+    token: string;
+    userId: string;
+    expiresAt: string;
+}
+export declare function registerLocalDevUser(options: {
+    root: string;
+    username: string;
+    password: string;
+    role?: TeamRole;
+    storage?: StorageProvider;
+}): Promise<TeamUser>;
+export declare function authenticateLocalDev(options: {
+    root: string;
+    username: string;
+    password: string;
+    storage?: StorageProvider;
+}): Promise<SessionToken>;
+export declare function authorize(root: string, token: string, minRole: TeamRole, storage?: StorageProvider): Promise<{
+    ok: boolean;
+    user?: TeamUser;
+    reason: string;
+}>;

package/dist/team/auth.js

@@ -0,0 +1,70 @@
+import { createHash, randomBytes, scryptSync, timingSafeEqual } from "node:crypto";
+import { FilesystemStorageProvider } from "../storage/provider.js";
+function hashPassword(password, salt) {
+    return scryptSync(password, salt, 32).toString("hex");
+}
+export async function registerLocalDevUser(options) {
+    if (options.password.length < 8)
+        throw new Error("password must be at least 8 characters");
+    const storage = options.storage ?? new FilesystemStorageProvider(options.root, ".agentdoctor/team");
+    const salt = randomBytes(16).toString("hex");
+    const user = {
+        id: `user_${createHash("sha1").update(options.username).digest("hex").slice(0, 10)}`,
+        username: options.username,
+        passwordHash: hashPassword(options.password, salt),
+        salt,
+        role: options.role ?? "member",
+        createdAt: new Date().toISOString(),
+        authMode: "local-dev",
+    };
+    await storage.set(`users/${user.id}.json`, `${JSON.stringify(user, null, 2)}\n`);
+    return {
+        ...user,
+        passwordHash: "[REDACTED]",
+        salt: "[REDACTED]",
+    };
+}
+export async function authenticateLocalDev(options) {
+    const storage = options.storage ?? new FilesystemStorageProvider(options.root, ".agentdoctor/team");
+    const keys = await storage.list("users");
+    for (const key of keys) {
+        const raw = await storage.get(key.startsWith("users/") ? key : `users/${key}`);
+        if (!raw)
+            continue;
+        const user = JSON.parse(raw);
+        if (user.username !== options.username)
+            continue;
+        const next = hashPassword(options.password, user.salt);
+        const a = Buffer.from(next, "hex");
+        const b = Buffer.from(user.passwordHash, "hex");
+        if (a.length !== b.length || !timingSafeEqual(a, b))
+            break;
+        const token = randomBytes(24).toString("hex");
+        const session = {
+            token,
+            userId: user.id,
+            expiresAt: new Date(Date.now() + 8 * 3600_000).toISOString(),
+        };
+        await storage.set(`sessions/${token}.json`, `${JSON.stringify(session, null, 2)}\n`);
+        return session;
+    }
+    throw new Error("invalid credentials");
+}
+export async function authorize(root, token, minRole, storage) {
+    const store = storage ?? new FilesystemStorageProvider(root, ".agentdoctor/team");
+    const raw = await store.get(`sessions/${token}.json`);
+    if (!raw)
+        return { ok: false, reason: "missing session" };
+    const session = JSON.parse(raw);
+    if (Date.parse(session.expiresAt) < Date.now())
+        return { ok: false, reason: "expired session" };
+    const userRaw = await store.get(`users/${session.userId}.json`);
+    if (!userRaw)
+        return { ok: false, reason: "missing user" };
+    const user = JSON.parse(userRaw);
+    const rank = { viewer: 1, member: 2, admin: 3, owner: 4 };
+    if ((rank[user.role] ?? 0) < (rank[minRole] ?? 99)) {
+        return { ok: false, reason: "insufficient role", user };
+    }
+    return { ok: true, user, reason: "authorized" };
+}

package/dist/types/index.d.ts

@@ -9,7 +9,7 @@ export type LanguageId = "typescript" | "javascript" | "python" | "dart" | "php"
 export type FrameworkId = "nextjs" | "react" | "vue" | "nuxt" | "svelte" | "nodejs" | "express" | "nestjs" | "flutter" | "laravel" | "django" | "fastapi" | "unknown";
 export type PackageManagerId = "npm" | "pnpm" | "yarn" | "bun" | "composer" | "pub" | "pip" | "poetry" | "cargo" | "gradle" | "unknown";
 export type MonorepoToolId = "npm-workspaces" | "pnpm-workspaces" | "turborepo" | "nx" | "multi-project" | "none";
-export type AgentId = "cursor" | "claude-code" | "codex";
+export type AgentId = "cursor" | "claude-code" | "codex" | "copilot" | "windsurf" | "gemini-cli" | "aider";
 export interface DiscoveredFile {
     /** Absolute path */
     absolutePath: string;
@@ -76,6 +76,10 @@ export interface AgentScores {
     cursor: number;
     "claude-code": number;
     codex: number;
+    copilot: number;
+    windsurf: number;
+    "gemini-cli": number;
+    aider: number;
 }
 export interface Scores {
     overall: number;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@praneeth_54/agentdoctor",
-  "version": "1.1.0",
-  "description": "Audit AI coding agent configuration in a repository — local, deterministic, no API key.",
+  "version": "2.0.0",
+  "description": "Codebase intelligence, repository analysis, safety controls, and MCP tools for developers and engineering teams.",
   "type": "module",
   "bin": {
     "agentdoctor": "./dist/cli/index.js"
@@ -54,6 +54,10 @@
     "cursor",
     "claude-code",
     "codex",
+    "copilot",
+    "windsurf",
+    "gemini",
+    "aider",
     "mcp",
     "security",
     "linter",
@@ -77,19 +81,22 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
     "commander": "^14.0.3",
-    "picocolors": "^1.1.1"
+    "picocolors": "^1.1.1",
+    "typescript": "^5.9.3"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
     "@types/node": "^22.19.1",
     "eslint": "^9.39.2",
     "prettier": "^3.7.4",
-    "tsx": "^4.21.0",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.50.0",
+    "tsx": "^4.23.13",
+    "typescript-eslint": "^8.70.0",
     "vitest": "^3.2.4"
   },
   "overrides": {
-    "js-yaml": "4.3.1"
+    "js-yaml": "4.3.2",
+    "fast-uri": "3.1.8",
+    "hono": "4.13.8",
+    "qs": "6.16.0"
   }
 }