atabey 0.0.13 → 0.0.14

package/framework-mcp/dist/src/cli/platforms/utils.js

@@ -0,0 +1,75 @@
+import fs from "fs";
+import path from "path";
+import { logger } from "../../shared/logger.js";
+import { UI } from "../utils/ui.js";
+import { ADAPTERS, SHIM_FILES } from "./core.js";
+export function resolveAdapter(input) {
+    let normalized = (input || "gemini").toLowerCase();
+    if (normalized === "antigravity") {
+        normalized = "antigravity-cli";
+    }
+    else if (normalized === "copilot" || normalized === "github") {
+        normalized = "codex";
+    }
+    let config;
+    if (normalized in ADAPTERS) {
+        config = { ...ADAPTERS[normalized] };
+    }
+    else {
+        UI.warning(`Unknown adapter "${input}". Falling back to gemini.`);
+        config = { ...ADAPTERS.gemini };
+    }
+    return config;
+}
+export function isAdapterShimFile(fileName) {
+    return SHIM_FILES.includes(fileName);
+}
+export function remapFrameworkContent(content, frameworkDir, adapterId) {
+    let result = content;
+    result = result.replace(/\{\{FRAMEWORK_DIR\}\}/g, frameworkDir);
+    result = result.replace(/\{\{ADAPTER\}\}/g, adapterId);
+    let agentFolder = "agents";
+    let knowledgeFolder = "knowledge";
+    if (frameworkDir !== ".atabey") {
+        if (adapterId === "antigravity-cli") {
+            agentFolder = "agents";
+            knowledgeFolder = "rules";
+        }
+        // Note: Grok uses the same directory structure as Gemini (".grok/agents").
+        // No override needed — default agentFolder = "agents" is correct.
+    }
+    const frameworkPattern = ".atabey/";
+    result = result.replace(new RegExp(frameworkPattern + "agents/", "g"), `${frameworkDir}/${agentFolder}/`);
+    result = result.replace(new RegExp(frameworkPattern + "knowledge/", "g"), `${frameworkDir}/${knowledgeFolder}/`);
+    result = result.replace(/\.atabey\//g, `${frameworkDir}/`);
+    result = result.replace(/`\.atabey`/g, `\`${frameworkDir}\``);
+    result = result.replace(/\.atabey(?![\w/-])/g, frameworkDir);
+    let backend = "apps/backend";
+    let frontend = "apps/web";
+    let docs = "docs";
+    let tests = "tests";
+    try {
+        const configPath = path.join(process.cwd(), frameworkDir, "config.json");
+        if (fs.existsSync(configPath)) {
+            const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+            if (config.paths) {
+                if (config.paths.backend)
+                    backend = config.paths.backend;
+                if (config.paths.frontend)
+                    frontend = config.paths.frontend;
+                if (config.paths.docs)
+                    docs = config.paths.docs;
+                if (config.paths.tests)
+                    tests = config.paths.tests;
+            }
+        }
+    }
+    catch (err) {
+        logger.debug("Failed to read config.json in remapFrameworkContent", err);
+    }
+    result = result.replace(/\{\{BACKEND_DIR\}\}/g, backend);
+    result = result.replace(/\{\{FRONTEND_DIR\}\}/g, frontend);
+    result = result.replace(/\{\{DOCS_DIR\}\}/g, docs);
+    result = result.replace(/\{\{TESTS_DIR\}\}/g, tests);
+    return result;
+}

package/framework-mcp/dist/src/cli/utils/claude.js

@@ -0,0 +1,57 @@
+import fs from "fs";
+import path from "path";
+import { writeTextFile } from "./fs.js";
+import { UI } from "./ui.js";
+/**
+ * Finds the Claude config file path (if it exists).
+ */
+export function findClaudeConfigPath() {
+    const home = process.env.HOME || process.env.USERPROFILE;
+    if (!home)
+        return null;
+    const possiblePaths = [
+        // Claude Desktop
+        path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json"), // macOS Claude Desktop
+        path.join(home, "AppData", "Roaming", "Claude", "claude_desktop_config.json"), // Windows Claude Desktop
+        // Claude Code CLI
+        path.join(home, ".claude.json"), // Global Claude Code CLI MCP config
+        // Legacy or system-specific paths
+        path.join(home, ".config", "claude", "config.json"),
+        path.join(home, ".claude", "config.json"),
+        path.join(home, "Library", "Application Support", "Claude Code", "config.json"),
+        path.join(home, ".config", "Claude", "config.json"),
+    ];
+    for (const p of possiblePaths) {
+        if (fs.existsSync(p)) {
+            return p;
+        }
+    }
+    return null;
+}
+/**
+ * Adds or updates an MCP server entry in Claude's config file.
+ */
+export function addMcpServerToClaude(configPath, serverName, serverConfig) {
+    try {
+        let config = { mcpServers: {} };
+        if (fs.existsSync(configPath)) {
+            const content = fs.readFileSync(configPath, "utf8");
+            config = JSON.parse(content);
+        }
+        if (!config.mcpServers) {
+            config.mcpServers = {};
+        }
+        config.mcpServers[serverName] = serverConfig;
+        // Ensure parent directory exists
+        const dir = path.dirname(configPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        writeTextFile(configPath, JSON.stringify(config, null, 2));
+        return true;
+    }
+    catch (e) {
+        UI.warning(`  Failed to add MCP server to Claude config at ${configPath}: ${e}`);
+        return false;
+    }
+}

package/framework-mcp/dist/src/cli/utils/compliance.js

@@ -0,0 +1,12 @@
+/**
+ * Compliance utilities for Agent Atabey.
+ *
+ * NOTE: The primary compliance scanner lives in framework-mcp:
+ *   framework-mcp/src/utils/compliance.ts
+ *
+ * This file re-exports the framework-mcp version for CLI compatibility.
+ * If you need to modify compliance logic, edit framework-mcp/src/utils/compliance.ts
+ * instead of this file.
+ */
+// Re-export everything from framework-mcp's compliance module
+export { isHighRiskOperation, scanProjectCompliance, verifyCorporateCompliance, verifyRiskAndAwaitApproval } from "../../../framework-mcp/src/utils/compliance.js";

package/framework-mcp/dist/src/cli/utils/fs.js

@@ -0,0 +1,138 @@
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import { appendFile, ensureDir, writeJsonFile, writeTextFile } from "../../shared/fs.js";
+import { remapFrameworkContent } from "../platforms/index.js";
+import { UI } from "./ui.js";
+export { appendFile, ensureDir, writeJsonFile, writeTextFile };
+export function updateGitIgnore(targetPath, frameworkDir = ".atabey", dryRun = false) {
+    const IGNORE_LINES = [
+        "# Agent Atabey",
+        `${frameworkDir}/logs/*.json`,
+        `${frameworkDir}/*.lock`,
+        `${frameworkDir}/memory/`,
+        ".env",
+        ".DS_Store",
+    ];
+    let content = "";
+    if (fs.existsSync(targetPath)) {
+        content = fs.readFileSync(targetPath, "utf8");
+    }
+    const lines = content.split("\n").map((l) => l.trim());
+    let added = false;
+    for (const line of IGNORE_LINES) {
+        if (!lines.includes(line)) {
+            content += (content.endsWith("\n") || content === "" ? "" : "\n") + line + "\n";
+            added = true;
+        }
+    }
+    if (added) {
+        if (dryRun) {
+            UI.info(`[DRY RUN] Would update .gitignore at ${targetPath}`);
+        }
+        else {
+            writeTextFile(targetPath, content);
+            UI.success(" .gitignore updated.");
+        }
+    }
+}
+export function copyDir(src, dest, skipSet = new Set(), nonDestructive = false, frameworkDir = ".gemini", targetScope = "", sanitizeJson, adapterId = "gemini", dryRun = false) {
+    const DEFAULT_SKIP = new Set(["node_modules", ".git", ".DS_Store", "package-lock.json"]);
+    const actualSkip = new Set([...DEFAULT_SKIP, ...skipSet]);
+    if (!fs.existsSync(dest) && !dryRun) {
+        fs.mkdirSync(dest, { recursive: true });
+    }
+    fs.readdirSync(src, { withFileTypes: true }).forEach((entry) => {
+        if (actualSkip.has(entry.name))
+            return;
+        const srcPath = path.join(src, entry.name);
+        // Physical folder remapping during copy.
+        // In unified mode (frameworkDir === ".atabey") folder names are always standard —
+        // agents/ stays agents/, knowledge/ stays knowledge/.
+        // Only remap when using a legacy non-unified adapter directory.
+        let effectiveEntryName = entry.name;
+        if (entry.isDirectory() && frameworkDir !== ".atabey") {
+            if (entry.name === "agents") {
+                if (adapterId === "antigravity-cli")
+                    effectiveEntryName = "skills";
+                else if (adapterId === "grok")
+                    effectiveEntryName = "plugins";
+            }
+            else if (entry.name === "knowledge") {
+                if (adapterId === "antigravity-cli")
+                    effectiveEntryName = "rules";
+            }
+        }
+        const destPath = path.join(dest, effectiveEntryName);
+        if (entry.isDirectory()) {
+            copyDir(srcPath, destPath, skipSet, nonDestructive, frameworkDir, targetScope, sanitizeJson, adapterId, dryRun);
+        }
+        else {
+            if (nonDestructive && fs.existsSync(destPath)) {
+                return;
+            }
+            const ext = path.extname(entry.name);
+            const textExtensions = [".md", ".json", ".js", ".ts", ".txt", ""];
+            if (textExtensions.includes(ext)) {
+                let content = fs.readFileSync(srcPath, "utf8");
+                content = remapFrameworkContent(content, frameworkDir, adapterId); // Use the new remap function
+                if (ext === ".json") {
+                    try {
+                        const json = JSON.parse(content);
+                        writeJsonFile(destPath, sanitizeJson(json, targetScope), dryRun);
+                    }
+                    catch {
+                        const fallback = content.replace(/workspace:[^"'\s]*/g, "*");
+                        writeTextFile(destPath, fallback, dryRun);
+                    }
+                }
+                else {
+                    content = content.replace(/workspace:[^"'\s]*/g, "*");
+                    content = remapFrameworkContent(content, frameworkDir, adapterId); // Apply remap once to the final content
+                    writeTextFile(destPath, content, dryRun);
+                }
+            }
+            else {
+                if (dryRun) {
+                    UI.info(`[DRY RUN] Would copy binary file: ${destPath}`);
+                }
+                else {
+                    fs.copyFileSync(srcPath, destPath);
+                }
+            }
+        }
+    });
+}
+export function collectFiles(dir, extensions) {
+    let results = [];
+    if (!fs.existsSync(dir))
+        return results;
+    const list = fs.readdirSync(dir);
+    list.forEach((file) => {
+        file = path.join(dir, file);
+        const stat = fs.statSync(file);
+        if (stat && stat.isDirectory()) {
+            if (!file.includes("node_modules") && !file.includes(".git")) {
+                results = results.concat(collectFiles(file, extensions));
+            }
+        }
+        else if (extensions.includes(path.extname(file))) {
+            results.push(file);
+        }
+    });
+    return results;
+}
+export function computeTypesHash(projectRoot, sharedDir) {
+    const walk = (d) => fs.readdirSync(d, { withFileTypes: true }).flatMap((e) => {
+        const fullPath = path.join(d, e.name);
+        return e.isDirectory() ? walk(fullPath) : (e.name.endsWith(".ts") ? [fullPath] : []);
+    });
+    const hash = crypto.createHash("sha256");
+    for (const filePath of walk(sharedDir).sort()) {
+        hash.update(path.relative(projectRoot, filePath));
+        hash.update("\0");
+        hash.update(fs.readFileSync(filePath));
+        hash.update("\0");
+    }
+    return hash.digest("hex");
+}

package/framework-mcp/dist/src/cli/utils/pkg.js

@@ -0,0 +1,282 @@
+import fs from "fs";
+import path from "path";
+import { writeJsonFile, writeTextFile } from "./fs.js";
+import { UI } from "./ui.js";
+export function getPackageVersion() {
+    const root = getPackageRoot();
+    const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+    return pkg.version;
+}
+export function getPackageManager() {
+    const override = process.env.ATABEY_PACKAGE_MANAGER;
+    if (override)
+        return override.toLowerCase();
+    const userAgent = process.env.npm_config_user_agent || "";
+    const npmExecPath = process.env.npm_execpath || "";
+    if (userAgent.includes("pnpm") || npmExecPath.includes("pnpm"))
+        return "pnpm";
+    if (userAgent.includes("yarn") || npmExecPath.includes("yarn"))
+        return "yarn";
+    // Check for lockfiles in target directory
+    if (fs.existsSync(path.join(process.cwd(), "pnpm-lock.yaml")) || fs.existsSync(path.join(process.cwd(), "pnpm-workspace.yaml")))
+        return "pnpm";
+    if (fs.existsSync(path.join(process.cwd(), "yarn.lock")))
+        return "yarn";
+    return "npm";
+}
+/**
+ * Robustly locates the atabey package root from the currently executing module (src via tsx or bin).
+ * Walks up from import.meta.url until it finds package.json with name === "atabey".
+ * This ensures getValidatorPath() and getPackageVersion() work correctly both in source tree
+ * AND when the package is consumed from node_modules after `npm install atabey` (global or local).
+ * Critical for AL validation (validate-al-registry) and cross-adapter inits to work from npm.
+ */
+function findAgentAtabeyPackageRoot() {
+    let current = path.dirname(new URL(import.meta.url).pathname);
+    const root = path.parse(current).root;
+    while (current !== root) {
+        if (path.basename(current) === "dist") {
+            current = path.dirname(current);
+            continue;
+        }
+        const pkgPath = path.join(current, "package.json");
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+                if (pkg.name === "atabey") {
+                    return current;
+                }
+            }
+            catch {
+                // ignore parse errors on intermediate package.jsons (e.g. user's project), continue
+            }
+        }
+        current = path.dirname(current);
+    }
+    // Fallback maintains prior behavior for unusual layouts
+    const __filenameLocal = new URL(import.meta.url).pathname;
+    const __dirnameLocal = path.dirname(__filenameLocal);
+    return path.join(__dirnameLocal, "../../..");
+}
+export function getPackageRoot() {
+    return findAgentAtabeyPackageRoot();
+}
+export function getValidatorPath() {
+    return path.join(getPackageRoot(), "bin", "validate-al-registry.js");
+}
+export function getDependencyVersions() {
+    const root = getPackageRoot();
+    const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+    const devDependencies = pkg.devDependencies || {};
+    const dependencies = pkg.dependencies || {};
+    return {
+        // ── Backend Core ──────────────────────────────────────────
+        "fastify": dependencies["fastify"] || "^5.0.0",
+        "@fastify/cors": dependencies["@fastify/cors"] || "^11.0.0",
+        "@fastify/swagger": dependencies["@fastify/swagger"] || "^9.0.0",
+        "@fastify/swagger-ui": dependencies["@fastify/swagger-ui"] || "^5.0.0",
+        "@fastify/rate-limit": dependencies["@fastify/rate-limit"] || "^10.0.0",
+        "@fastify/static": dependencies["@fastify/static"] || "^8.0.0",
+        "zod": dependencies["zod"] || "^3.24.2",
+        // ── Database / ORM ────────────────────────────────────────
+        "kysely": dependencies["kysely"] || "^0.27.0",
+        "typeorm": dependencies["typeorm"] || "^0.3.0",
+        "reflect-metadata": dependencies["reflect-metadata"] || "^0.2.0",
+        "pg": dependencies["pg"] || "^8.13.0",
+        "better-sqlite3": dependencies["better-sqlite3"] || "^11.0.0",
+        // ── Authentication ────────────────────────────────────────
+        "bcrypt": dependencies["bcrypt"] || "^5.1.0",
+        "@types/bcrypt": devDependencies["@types/bcrypt"] || "^5.0.0",
+        "jsonwebtoken": dependencies["jsonwebtoken"] || "^9.0.0",
+        "@types/jsonwebtoken": devDependencies["@types/jsonwebtoken"] || "^9.0.0",
+        // ── Logging ───────────────────────────────────────────────
+        "pino": dependencies["pino"] || "^9.0.0",
+        "pino-pretty": devDependencies["pino-pretty"] || "^12.0.0",
+        // ── Validation ────────────────────────────────────────────
+        "@fastify/type-provider-typebox": dependencies["@fastify/type-provider-typebox"] || "^5.0.0",
+        // Backend devDependencies
+        "@types/node": devDependencies["@types/node"] || "^22.13.4",
+        "tsx": devDependencies["tsx"] || "^4.19.4",
+        "typescript": devDependencies["typescript"] || "^5.9.3",
+        "vitest-backend": devDependencies["vitest"] || "^3.0.5",
+        // ── Frontend Core ─────────────────────────────────────────
+        "@vitejs/plugin-react": dependencies["@vitejs/plugin-react"] || "^5.0.0",
+        "vite": dependencies["vite"] || "^7.0.0",
+        "react": dependencies["react"] || "^19.0.0",
+        "react-dom": dependencies["react-dom"] || "^19.0.0",
+        "lucide-react": dependencies["lucide-react"] || "^0.468.0",
+        "react-router-dom": dependencies["react-router-dom"] || "^7.0.0",
+        "@tanstack/react-query": dependencies["@tanstack/react-query"] || "^5.0.0",
+        // Frontend devDependencies
+        "@types/react": devDependencies["@types/react"] || "^19.0.0",
+        "@types/react-dom": devDependencies["@types/react-dom"] || "^19.0.0",
+        "vitest-frontend": devDependencies["vitest"] || "^3.0.5",
+        // ── Testing ───────────────────────────────────────────────
+        "@playwright/test": devDependencies["@playwright/test"] || "^1.50.0",
+    };
+}
+export function mergePackageJson(targetPath, sourcePath) {
+    let targetPkg = {};
+    if (fs.existsSync(targetPath)) {
+        try {
+            targetPkg = JSON.parse(fs.readFileSync(targetPath, "utf8"));
+        }
+        catch {
+            UI.warning("  Could not parse existing package.json, creating a new one.");
+        }
+    }
+    const sourcePkg = JSON.parse(fs.readFileSync(sourcePath, "utf8"));
+    const sanitizeDeps = (deps) => {
+        if (!deps)
+            return deps;
+        const cleaned = {};
+        for (const [name, version] of Object.entries(deps)) {
+            cleaned[name] = (typeof version === "string" && version.startsWith("workspace:")) ? "*" : String(version || "");
+        }
+        return cleaned;
+    };
+    const actualTargetScope = targetPkg.name && targetPkg.name.startsWith("@")
+        ? targetPkg.name.split("/")[0]
+        : (targetPkg.name ? `@${targetPkg.name}` : "");
+    // Cleanup potential leftovers from previous bugged runs where atabey was renamed to target name
+    if (actualTargetScope) {
+        const scopeName = actualTargetScope.startsWith("@") ? actualTargetScope.slice(1) : actualTargetScope;
+        const cleanup = (obj) => {
+            if (!obj)
+                return;
+            delete obj[scopeName];
+            delete obj[actualTargetScope];
+            delete obj["atabey"]; // Will be re-added correctly
+        };
+        cleanup(targetPkg.devDependencies);
+        cleanup(targetPkg.dependencies);
+    }
+    targetPkg.dependencies = sanitizeDeps({
+        ...targetPkg.dependencies,
+        ...sourcePkg.dependencies
+    });
+    // Merge scripts
+    const pkgMgr = getPackageManager();
+    const runCmd = pkgMgr === "yarn" ? "yarn" : (pkgMgr === "pnpm" ? "pnpm" : "npm run");
+    targetPkg.scripts = {
+        ...targetPkg.scripts,
+        "atabey:status": "atabey status",
+        "atabey:trace": "atabey trace:new",
+        "atabey:verify": "atabey verify-contract",
+        "atabey:check": "atabey check",
+        "atabey:test": "vitest run",
+        "atabey:test:watch": "vitest",
+        "atabey:build": `${runCmd} build --prefix framework-mcp`,
+    };
+    const sourceDevDeps = sourcePkg.devDependencies || {};
+    targetPkg.devDependencies = sanitizeDeps({
+        ...targetPkg.devDependencies,
+        "atabey": `^${sourcePkg.version}`,
+        ...(sourceDevDeps["@modelcontextprotocol/sdk"] ? { "@modelcontextprotocol/sdk": sourceDevDeps["@modelcontextprotocol/sdk"] } : {}),
+        ...(sourceDevDeps["zod"] ? { "zod": sourceDevDeps["zod"] } : {}),
+        ...(sourceDevDeps["ts-morph"] ? { "ts-morph": sourceDevDeps["ts-morph"] } : {}),
+        ...(sourceDevDeps["typescript"] ? { "typescript": sourceDevDeps["typescript"] } : {}),
+        ...(sourceDevDeps["@types/node"] ? { "@types/node": sourceDevDeps["@types/node"] } : {}),
+        ...(sourceDevDeps["tsx"] ? { "tsx": sourceDevDeps["tsx"] } : {}),
+        ...(sourceDevDeps["vitest"] ? { "vitest": sourceDevDeps["vitest"] } : {})
+    });
+    if (targetPkg.peerDependencies) {
+        targetPkg.peerDependencies = sanitizeDeps(targetPkg.peerDependencies);
+    }
+    if (targetPkg.optionalDependencies) {
+        targetPkg.optionalDependencies = sanitizeDeps(targetPkg.optionalDependencies);
+    }
+    // Ensure basic fields
+    if (!targetPkg.name)
+        targetPkg.name = path.basename(process.cwd());
+    if (!targetPkg.version)
+        targetPkg.version = "0.0.12";
+    if (!targetPkg.type)
+        targetPkg.type = "module";
+    // DO NOT add framework-mcp to workspaces in consumer projects
+    // if (!targetPkg.workspaces) targetPkg.workspaces = ["framework-mcp"];
+    // Add metadata
+    targetPkg.atabey = {
+        version: sourcePkg.version || "0.0.0",
+        initializedAt: new Date().toISOString(),
+    };
+    writeJsonFile(targetPath, targetPkg);
+    UI.success(" package.json updated with Atabey scripts and dependencies.");
+}
+export function sanitizeJson(obj, targetScope = "") {
+    if (typeof obj !== "object" || obj === null)
+        return obj;
+    if (Array.isArray(obj))
+        return obj.map(item => sanitizeJson(item, targetScope));
+    const cleaned = {};
+    const record = obj;
+    for (const [key, value] of Object.entries(record)) {
+        let finalKey = key;
+        let finalValue = value;
+        // Remove UnoCSS related keys or values
+        if (typeof key === "string" && key.includes("unocss"))
+            continue;
+        if (typeof value === "string" && value.includes("unocss")) {
+            continue; // Skip this script/field
+        }
+        // Replace scope if needed
+        if (targetScope) {
+            const scopeName = targetScope.startsWith("@") ? targetScope.slice(1) : targetScope;
+            // Handle scoped: @atabey/foo -> @target/foo
+            if (typeof key === "string" && key.startsWith("@atabey/")) {
+                finalKey = key.replace("@atabey/", `${targetScope}/`);
+            }
+            if (typeof value === "string" && value.startsWith("@atabey/")) {
+                finalValue = value.replace("@atabey/", `${targetScope}/`);
+            }
+            // Handle unscoped: atabey-foo -> target-foo
+            if (typeof key === "string" && key.startsWith("atabey-")) {
+                finalKey = key.replace("atabey-", `${scopeName}-`);
+            }
+            if (typeof value === "string" && value.startsWith("atabey-")) {
+                finalValue = value.replace("atabey-", `${scopeName}-`);
+            }
+            // Handle atabey -> target (ONLY for the package name)
+            if (key === "name" && value === "atabey") {
+                finalValue = scopeName;
+            }
+            // Preserve atabey in dependencies and bin
+            // (No action needed as finalKey/finalValue default to original)
+            if (typeof value === "string" && value.startsWith("workspace:")) {
+                finalValue = "*";
+            }
+        }
+        else if (typeof value === "string" && value.startsWith("workspace:")) {
+            finalValue = "*";
+        }
+        cleaned[finalKey] = (typeof finalValue === "object" && finalValue !== null) ? sanitizeJson(finalValue, targetScope) : finalValue;
+    }
+    return cleaned;
+}
+export function deepCleanProtocols(dir, targetScope = "") {
+    if (!fs.existsSync(dir))
+        return;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name === "node_modules" || entry.name === ".git")
+                continue;
+            deepCleanProtocols(fullPath, targetScope);
+        }
+        else if (entry.name === "package.json") {
+            try {
+                const content = fs.readFileSync(fullPath, "utf8");
+                const json = JSON.parse(content);
+                const cleaned = JSON.stringify(sanitizeJson(json, targetScope), null, 2);
+                writeTextFile(fullPath, cleaned);
+            }
+            catch {
+                // ignore malformed json
+            }
+        }
+        else if (entry.name === "package-lock.json") {
+            fs.unlinkSync(fullPath);
+        }
+    }
+}

package/framework-mcp/dist/src/cli/utils/quality.js

@@ -0,0 +1,9 @@
+/**
+ * Code Quality utilities for Agent Atabey.
+ *
+ * NOTE: The primary quality scanner lives in framework-mcp:
+ *   framework-mcp/src/utils/quality.ts
+ *
+ * This file re-exports the framework-mcp version for CLI compatibility.
+ */
+export { analyzePathQuality } from "../../../framework-mcp/src/utils/quality.js";