@praneeth_54/agentdoctor 1.1.1 → 2.0.1

package/dist/workspace/index.js

@@ -0,0 +1,220 @@
+import { createHash, randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { atomicWriteTextFile } from "../utils/fs.js";
+import { isPathInsideRoot, resolveRepoRoot } from "../utils/path.js";
+export const WORKSPACE_SCHEMA_VERSION = "1.0.0";
+function workspacesDir(controlRoot) {
+    return path.join(resolveRepoRoot(controlRoot), ".agentdoctor", "workspaces");
+}
+function workspaceFile(controlRoot, id) {
+    if (!/^[a-zA-Z0-9_-]{1,64}$/.test(id)) {
+        throw new Error("invalid workspace id");
+    }
+    return path.join(workspacesDir(controlRoot), `${id}.json`);
+}
+function normalizeRoot(rootInput) {
+    return resolveRepoRoot(rootInput);
+}
+export async function initWorkspace(options) {
+    const controlRoot = resolveRepoRoot(options.controlRoot);
+    const id = options.id ??
+        `ws_${createHash("sha256").update(`${options.name}:${randomUUID()}`).digest("hex").slice(0, 12)}`;
+    const now = new Date().toISOString();
+    const roots = [];
+    if (options.repositoryRoot) {
+        roots.push(normalizeRoot(options.repositoryRoot));
+    }
+    const model = {
+        schemaVersion: WORKSPACE_SCHEMA_VERSION,
+        id,
+        name: options.name.trim() || id,
+        repositoryRoots: roots,
+        allowCrossRead: options.allowCrossRead === true,
+        createdAt: now,
+        updatedAt: now,
+    };
+    await fs.mkdir(workspacesDir(controlRoot), { recursive: true });
+    const target = workspaceFile(controlRoot, id);
+    try {
+        await fs.access(target);
+        throw new Error(`workspace already exists: ${id}`);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith("workspace already exists")) {
+            throw error;
+        }
+    }
+    await atomicWriteTextFile(target, `${JSON.stringify(model, null, 2)}\n`);
+    return model;
+}
+export async function loadWorkspace(controlRoot, id) {
+    try {
+        const raw = await fs.readFile(workspaceFile(controlRoot, id), "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed ||
+            parsed.schemaVersion !== WORKSPACE_SCHEMA_VERSION ||
+            !Array.isArray(parsed.repositoryRoots)) {
+            return null;
+        }
+        return {
+            ...parsed,
+            allowCrossRead: parsed.allowCrossRead === true,
+            repositoryRoots: parsed.repositoryRoots.map((r) => normalizeRoot(r)),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function listWorkspaces(controlRoot) {
+    const dir = workspacesDir(controlRoot);
+    let entries;
+    try {
+        entries = await fs.readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of entries) {
+        if (!name.endsWith(".json"))
+            continue;
+        const id = name.slice(0, -".json".length);
+        const ws = await loadWorkspace(controlRoot, id);
+        if (ws)
+            out.push(ws);
+    }
+    return out.sort((a, b) => a.id.localeCompare(b.id));
+}
+export async function addRepositoryToWorkspace(options) {
+    const ws = await loadWorkspace(options.controlRoot, options.workspaceId);
+    if (!ws)
+        throw new Error(`workspace not found: ${options.workspaceId}`);
+    const root = normalizeRoot(options.repositoryRoot);
+    if (!ws.repositoryRoots.includes(root)) {
+        ws.repositoryRoots.push(root);
+        ws.updatedAt = new Date().toISOString();
+        await atomicWriteTextFile(workspaceFile(options.controlRoot, ws.id), `${JSON.stringify(ws, null, 2)}\n`);
+    }
+    return ws;
+}
+export async function removeWorkspace(controlRoot, id) {
+    try {
+        await fs.unlink(workspaceFile(controlRoot, id));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function workspaceStatus(controlRoot, id) {
+    const ws = await loadWorkspace(controlRoot, id);
+    if (!ws)
+        return { ok: false, missingRoots: [], error: "workspace not found" };
+    const missingRoots = [];
+    for (const root of ws.repositoryRoots) {
+        try {
+            const st = await fs.stat(root);
+            if (!st.isDirectory())
+                missingRoots.push(root);
+        }
+        catch {
+            missingRoots.push(root);
+        }
+    }
+    return { ok: missingRoots.length === 0, workspace: ws, missingRoots };
+}
+/**
+ * Isolation gate: a path may be read only when it is inside the operation's own
+ * repositoryRoot, OR (allowCrossRead && both roots are members of the same workspace).
+ */
+export function assertWorkspacePathAccess(options) {
+    const operationRoot = normalizeRoot(options.operationRoot);
+    const target = path.resolve(options.targetPath);
+    if (isPathInsideRoot(operationRoot, target)) {
+        return {
+            allowed: true,
+            reason: "inside operation repository root",
+            requestedRoot: operationRoot,
+            targetRoot: operationRoot,
+            ...(options.workspace ? { workspaceId: options.workspace.id } : {}),
+        };
+    }
+    if (!options.workspace) {
+        return {
+            allowed: false,
+            reason: "path outside operation root and no workspace context",
+            requestedRoot: operationRoot,
+        };
+    }
+    const members = options.workspace.repositoryRoots.map(normalizeRoot);
+    if (!members.includes(operationRoot)) {
+        return {
+            allowed: false,
+            reason: "operation root is not a member of the workspace",
+            workspaceId: options.workspace.id,
+            requestedRoot: operationRoot,
+        };
+    }
+    const targetMember = members.find((root) => isPathInsideRoot(root, target));
+    if (!targetMember) {
+        return {
+            allowed: false,
+            reason: "target path is not under any workspace member root",
+            workspaceId: options.workspace.id,
+            requestedRoot: operationRoot,
+        };
+    }
+    if (targetMember === operationRoot) {
+        return {
+            allowed: true,
+            reason: "inside operation repository root",
+            workspaceId: options.workspace.id,
+            requestedRoot: operationRoot,
+            targetRoot: targetMember,
+        };
+    }
+    if (!options.workspace.allowCrossRead) {
+        return {
+            allowed: false,
+            reason: "cross-repo read denied: target is under another workspace member and allowCrossRead=false",
+            workspaceId: options.workspace.id,
+            requestedRoot: operationRoot,
+            targetRoot: targetMember,
+        };
+    }
+    return {
+        allowed: true,
+        reason: "allowCrossRead enabled for same-workspace member",
+        workspaceId: options.workspace.id,
+        requestedRoot: operationRoot,
+        targetRoot: targetMember,
+    };
+}
+/**
+ * Read a file only when workspace isolation allows it.
+ */
+export async function readFileWithinWorkspace(options) {
+    const access = assertWorkspacePathAccess({
+        workspace: options.workspace,
+        operationRoot: options.operationRoot,
+        targetPath: options.targetPath,
+    });
+    if (!access.allowed) {
+        return { ok: false, access, error: access.reason };
+    }
+    try {
+        const buf = await fs.readFile(path.resolve(options.targetPath));
+        const max = options.maxBytes ?? 1024 * 1024;
+        const content = buf.subarray(0, max).toString("utf8");
+        return { ok: true, content, access };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            access,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@praneeth_54/agentdoctor",
-  "version": "1.1.1",
-  "description": "Audit AI coding agent configuration in a repository — local, deterministic, no API key.",
+  "version": "2.0.1",
+  "description": "Engineering assurance for AI coding agents — repository intelligence, change evidence, safety controls, and MCP tools.",
   "type": "module",
   "bin": {
     "agentdoctor": "./dist/cli/index.js"
@@ -40,7 +40,7 @@
     "validate:project-brain": "tsx validation/project-brain/run.ts",
     "validate:project-brain:real-world": "tsx validation/project-brain/real-world-run.ts",
     "benchmark:project-brain": "tsx validation/project-brain/benchmark.ts",
-    "verify": "npm run typecheck && npm run lint && npm run format:check && npm test && npm run build",
+    "verify": "npm run typecheck && npm run lint && npm run format:check && npm run build && npm test",
     "verify:understanding": "npm run typecheck && npm run test:understanding",
     "verify:project-brain": "npm run typecheck && npm run test:understanding && npm run validate:project-brain && npm run benchmark:project-brain",
     "verify:mcp": "npm run typecheck && npm run test:mcp",
@@ -54,7 +54,14 @@
     "cursor",
     "claude-code",
     "codex",
+    "copilot",
+    "windsurf",
+    "gemini",
+    "aider",
     "mcp",
+    "change-assurance",
+    "evidence",
+    "engineering-assurance",
     "security",
     "linter",
     "cli",
@@ -76,8 +83,12 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.30.0",
+    "@types/pg": "^8.23.1",
     "commander": "^14.0.3",
-    "picocolors": "^1.1.1"
+    "jose": "^6.2.12",
+    "pg": "^8.23.0",
+    "picocolors": "^1.1.1",
+    "typescript": "^5.9.3"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
@@ -85,7 +96,6 @@
     "eslint": "^9.39.2",
     "prettier": "^3.7.4",
     "tsx": "^4.23.13",
-    "typescript": "^5.9.3",
     "typescript-eslint": "^8.70.0",
     "vitest": "^3.2.4"
   },