agent-enderun 0.8.8 → 0.9.1

package/framework-mcp/dist/tools/contract.js

@@ -1,197 +0,0 @@
-import fs from "fs";
-import path from "path";
-import crypto from "crypto";
-import { Project } from "ts-morph";
-import { getFrameworkDir, collectFilesRecursively } from "../utils.js";
-import { VERIFY_CONTRACT_INTEGRITY_ARGS_SCHEMA } from "../schemas.js";
-function calculateContractHash(sharedTypesDir, projectRoot) {
-    const files = collectFilesRecursively(sharedTypesDir, new Set(["ts"])).sort();
-    const hash = crypto.createHash("sha256");
-    files.forEach((filePath) => {
-        hash.update(path.relative(projectRoot, filePath));
-        hash.update("\0");
-        hash.update(fs.readFileSync(filePath));
-        hash.update("\0");
-    });
-    return hash.digest("hex");
-}
-export const contractTools = [
-    {
-        name: "verify_api_contract",
-        description: "Verify if the shared-types match the stored contract hash in contract.version.json.",
-        inputSchema: { type: "object", properties: {} },
-    },
-    {
-        name: "update_contract_hash",
-        description: "Generate a new hash for shared-types and update contract.version.json.",
-        inputSchema: { type: "object", properties: {} },
-    },
-    {
-        name: "verify_contract_integrity",
-        description: "Deeply analyzes API documentation and shared types to ensure they are perfectly synchronized.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                domain: {
-                    type: "string",
-                    description: "The API domain to verify (e.g. 'auth', 'user')",
-                },
-            },
-            required: ["domain"],
-        },
-    },
-    {
-        name: "validate_frontend_api_contract",
-        description: "Scans frontend hooks for API calls and compares them against backend API documentation and contracts. Returns mismatches (missing endpoints, type issues, etc.).",
-        inputSchema: {
-            type: "object",
-            properties: {
-                frontendHooksPath: {
-                    type: "string",
-                    description: "Relative path to frontend hooks directory (default: apps/web/src/pages)",
-                },
-                backendApiDocsPath: {
-                    type: "string",
-                    description: "Relative path to backend API documentation (default: docs/api)",
-                },
-            },
-        },
-    },
-];
-export const contractHandlers = {
-    verify_api_contract: async (args, projectRoot) => {
-        try {
-            const sharedTypesDir = path.join(projectRoot, "apps/backend/src/types");
-            const contractJsonPath = path.join(projectRoot, "apps/backend/contract.version.json");
-            if (!fs.existsSync(sharedTypesDir) || !fs.existsSync(contractJsonPath))
-                return { content: [{ type: "text", text: "Missing shared-types directory or contract.version.json" }] };
-            const currentHash = calculateContractHash(sharedTypesDir, projectRoot);
-            const storedHash = JSON.parse(fs.readFileSync(contractJsonPath, "utf-8")).contract_hash;
-            return { content: [{ type: "text", text: currentHash === storedHash ? "✅ MATCH: Contract is valid and synchronized." : `❌ MISMATCH: Current hash (${currentHash.slice(0, 8)}...) does not match stored hash (${storedHash.slice(0, 8)}...).` }] };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Contract integrity check failed." }] };
-        }
-    },
-    update_contract_hash: async (args, projectRoot) => {
-        try {
-            const sharedTypesDir = path.join(projectRoot, "apps/backend/src/types");
-            const contractJsonPath = path.join(projectRoot, "apps/backend/contract.version.json");
-            if (!fs.existsSync(sharedTypesDir))
-                return { content: [{ type: "text", text: "Missing shared-types directory" }] };
-            const files = collectFilesRecursively(sharedTypesDir, new Set(["ts"])).sort();
-            if (files.length === 0)
-                return { content: [{ type: "text", text: "⚠️ WARNING: No TypeScript files found in shared-types/src. Hash not updated." }] };
-            const currentHash = calculateContractHash(sharedTypesDir, projectRoot);
-            const contractJson = fs.existsSync(contractJsonPath) ? JSON.parse(fs.readFileSync(contractJsonPath, "utf-8")) : {};
-            contractJson.contract_hash = currentHash;
-            contractJson.last_updated = new Date().toISOString();
-            fs.writeFileSync(contractJsonPath, JSON.stringify(contractJson, null, 2));
-            return { content: [{ type: "text", text: `SUCCESS: Contract hash updated to ${currentHash}` }] };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Failed to update contract hash." }] };
-        }
-    },
-    verify_contract_integrity: async (args, projectRoot) => {
-        const parsed = VERIFY_CONTRACT_INTEGRITY_ARGS_SCHEMA.safeParse(args ?? {});
-        if (!parsed.success)
-            return { content: [{ type: "text", text: "Invalid domain argument." }] };
-        try {
-            const frameworkDir = getFrameworkDir(projectRoot);
-            const apiDocPath = path.join(projectRoot, frameworkDir, "docs/api", `${parsed.data.domain}.md`);
-            const sharedTypesDir = path.join(projectRoot, "apps/backend/src/types");
-            if (!fs.existsSync(apiDocPath))
-                return { content: [{ type: "text", text: `API documentation not found for domain: ${parsed.data.domain}` }] };
-            if (!fs.existsSync(sharedTypesDir))
-                return { content: [{ type: "text", text: "Shared types directory not found." }] };
-            const project = new Project();
-            project.addSourceFilesAtPaths(path.join(sharedTypesDir, "**/*.ts"));
-            const mentionedTypes = Array.from(fs.readFileSync(apiDocPath, "utf-8").matchAll(/`([^`]+)`/g))
-                .map(m => m[1])
-                .filter(t => /^[A-Z][a-zA-Z0-9]+(DTO|Response|Request|Status|Type)?$/.test(t));
-            const uniqueTypes = Array.from(new Set(mentionedTypes));
-            const missingTypes = uniqueTypes.filter(t => {
-                const found = project.getSourceFiles().some(sf => sf.getInterface(t) || sf.getTypeAlias(t) || sf.getEnum(t) || sf.getClass(t));
-                return !found;
-            });
-            return { content: [{ type: "text", text: `### CONTRACT INTEGRITY SHIELD: ${parsed.data.domain.toUpperCase()}\n\n` + `- **Missing/Undefined Types:** ${missingTypes.length > 0 ? `⚠️ ${missingTypes.join(", ")}` : "✅ All types synchronized"}\n\n` + `**Result:** ${missingTypes.length === 0 ? "PASSED" : "FAILED"}` }] };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Contract verification failed." }] };
-        }
-    },
-    validate_frontend_api_contract: async (args, projectRoot) => {
-        const a = args;
-        const frontendPath = a?.frontendHooksPath || "apps/web/src/pages";
-        const backendDocsPath = a?.backendApiDocsPath || "docs/api";
-        try {
-            const fullFrontendPath = path.join(projectRoot, frontendPath);
-            const fullBackendDocsPath = path.join(projectRoot, backendDocsPath);
-            if (!fs.existsSync(fullFrontendPath)) {
-                return { content: [{ type: "text", text: `Frontend hooks path not found: ${frontendPath}` }] };
-            }
-            const hookFiles = collectFilesRecursively(fullFrontendPath, new Set(["ts", "tsx"]));
-            const apiCalls = [];
-            // Hook dosyalarındaki fetch çağrılarını ve response tiplerini çıkar
-            for (const file of hookFiles) {
-                const content = fs.readFileSync(file, "utf-8");
-                // Basit regex ile endpoint + response tipi yakala
-                const matches = content.matchAll(/(?:const\s+\w+\s*[:=]\s*await\s+)?fetch\(['"`](\/api\/[^'"`]+)['"`][^)]*\)\s*(?:\.then[^;]+)?(?:\s*as\s+([A-Z][a-zA-Z0-9]+)|:\s*([A-Z][a-zA-Z0-9]+))?/g);
-                for (const match of matches) {
-                    const endpoint = match[1];
-                    const responseType = match[2] || match[3];
-                    apiCalls.push({ endpoint, responseType });
-                }
-            }
-            const uniqueEndpoints = Array.from(new Set(apiCalls.map(c => c.endpoint)));
-            if (!fs.existsSync(fullBackendDocsPath)) {
-                return { content: [{ type: "text", text: `Backend API docs path not found: ${backendDocsPath}` }] };
-            }
-            const backendDocFiles = collectFilesRecursively(fullBackendDocsPath, new Set(["md"]));
-            const documentedEndpoints = [];
-            for (const file of backendDocFiles) {
-                const content = fs.readFileSync(file, "utf-8");
-                const matches = content.matchAll(/`?(\/api\/[a-zA-Z0-9/_-]+)`?/g);
-                for (const match of matches) {
-                    documentedEndpoints.push(match[1]);
-                }
-            }
-            const missingInDocs = uniqueEndpoints.filter(ep => !documentedEndpoints.some(d => ep.startsWith(d)));
-            const missingInHooks = documentedEndpoints.filter(d => !uniqueEndpoints.some(e => e.startsWith(d)));
-            let report = `### FRONTEND ↔ BACKEND CONTRACT VALIDATION REPORT\n\n`;
-            report += `**Scanned Frontend Hooks:** ${uniqueEndpoints.length} unique endpoints found\n`;
-            report += `**Scanned Backend API Docs:** ${documentedEndpoints.length} endpoints documented\n\n`;
-            if (missingInDocs.length > 0) {
-                report += `⚠️ **Endpoints called from frontend but NOT documented in backend:**\n${missingInDocs.map(e => `- ${e}`).join("\n")}\n\n`;
-            }
-            else {
-                report += `✅ All frontend-called endpoints are documented in backend.\n\n`;
-            }
-            if (missingInHooks.length > 0) {
-                report += `ℹ️ **Endpoints documented in backend but NOT used in scanned frontend hooks:**\n${missingInHooks.map(e => `- ${e}`).join("\n")}\n\n`;
-            }
-            // Basit tip karşılaştırması (eğer responseType varsa)
-            const typeMismatches = [];
-            for (const call of apiCalls) {
-                if (call.responseType) {
-                    const docContent = backendDocFiles
-                        .map(f => fs.readFileSync(f, "utf-8"))
-                        .join("\n");
-                    if (!docContent.includes(call.responseType)) {
-                        typeMismatches.push(`${call.endpoint} → expected type "${call.responseType}" not found in docs`);
-                    }
-                }
-            }
-            if (typeMismatches.length > 0) {
-                report += `⚠️ **Potential Type Mismatches:**\n${typeMismatches.map(m => `- ${m}`).join("\n")}\n\n`;
-            }
-            report += `**Result:** ${missingInDocs.length === 0 && typeMismatches.length === 0 ? "PASSED" : "FAILED (see mismatches above)"}`;
-            return { content: [{ type: "text", text: report }] };
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            return { content: [{ type: "text", text: `Validation failed: ${message}` }] };
-        }
-    },
-};

package/framework-mcp/dist/tools/framework.js

@@ -1,225 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { getFrameworkDir, collectMarkdownArtifacts, FRAMEWORK_VERSION } from "../utils.js";
-export const frameworkTools = [
-    {
-        name: "get_framework_status",
-        description: "Get the current status of the AI Agent Framework, including active phase and agent states.",
-        inputSchema: { type: "object", properties: {} },
-    },
-    {
-        name: "get_project_gaps",
-        description: "Scans the project structure against the defined standards in ENDERUN.md and identifies missing files, folders, or documentation.",
-        inputSchema: { type: "object", properties: {} },
-    },
-    {
-        name: "get_memory_insights",
-        description: "Analyze PROJECT_MEMORY.md and BRAIN_DASHBOARD.md to provide insights on what was done, what is being done, and the history.",
-        inputSchema: { type: "object", properties: {} },
-    },
-    {
-        name: "codebase_context",
-        description: "Compatibility helper for non-code context discovery. Lists known markdown artifacts under docs/ and memory files.",
-        inputSchema: { type: "object", properties: {} },
-    },
-    {
-        name: "get_system_time",
-        description: "Get the current system time in ISO-8601 format (UTC). Use this instead of Shell 'date' commands.",
-        inputSchema: { type: "object", properties: {} },
-    },
-    {
-        name: "bootstrap_legacy_memory",
-        description: "Analyzes a pre-existing codebase to automatically generate the initial project memory, learning its tech stack and architecture.",
-        inputSchema: { type: "object", properties: {} },
-    },
-    {
-        name: "verify_framework_health",
-        description: "Runs the framework's internal 'check' command and reports system health status via MCP.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                detailed: { type: "boolean", default: false, description: "Include detailed issues if any." },
-            },
-        },
-    },
-];
-export const frameworkHandlers = {
-    bootstrap_legacy_memory: async (args, projectRoot) => {
-        try {
-            const frameworkDir = getFrameworkDir(projectRoot);
-            const memoryPath = path.join(projectRoot, frameworkDir, "PROJECT_MEMORY.md");
-            const pkgPath = path.join(projectRoot, "package.json");
-            let techStack = "Unknown";
-            if (fs.existsSync(pkgPath)) {
-                const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-                const allDeps = Object.keys(pkg.dependencies || {}).concat(Object.keys(pkg.devDependencies || {}));
-                const detected = [];
-                if (allDeps.includes("react"))
-                    detected.push("React");
-                if (allDeps.includes("next"))
-                    detected.push("Next.js");
-                if (allDeps.includes("typescript"))
-                    detected.push("TypeScript");
-                if (detected.length > 0)
-                    techStack = detected.join(", ");
-            }
-            const date = new Date().toISOString().split("T")[0];
-            const bootstrapContent = `# PROJECT MEMORY — Legacy Onboarding\n\n## CURRENT STATUS\n\n| Active Phase | Profile | Last Update | Active Trace ID | Blockers |\n| PHASE_1 | Full | ${date} | — | Legacy Onboarding |`;
-            if (fs.existsSync(memoryPath))
-                fs.copyFileSync(memoryPath, memoryPath + ".bak");
-            fs.writeFileSync(memoryPath, bootstrapContent);
-            return { content: [{ type: "text", text: `Legacy Codebase Bootstrap complete. Detected Stack: ${techStack}.` }] };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Failed to bootstrap legacy memory." }] };
-        }
-    },
-    get_framework_status: async (args, projectRoot) => {
-        try {
-            const frameworkDir = getFrameworkDir(projectRoot);
-            const memoryPath = path.join(projectRoot, frameworkDir, "PROJECT_MEMORY.md");
-            const memoryContent = fs.readFileSync(memoryPath, "utf-8");
-            const statusRowMatch = memoryContent.match(/\| Active Phase \| Profile \| Last Update \| Active Trace ID \| Blockers \|\n\| :----------- \| :------ \| :---------- \| :-------------- \| :------- \|\n\| ([^|]+) \| ([^|]+) \| ([^|]+) \| ([^|]+) \| ([^|]+) \|/);
-            const phase = statusRowMatch?.[1]?.trim() ?? "UNKNOWN";
-            const profile = statusRowMatch?.[2]?.trim() ?? "UNKNOWN";
-            return {
-                content: [{ type: "text", text: `Framework active (v${FRAMEWORK_VERSION}). Phase: ${phase}. Profile: ${profile}.` }],
-            };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Failed to get framework status." }] };
-        }
-    },
-    get_project_gaps: async (args, projectRoot) => {
-        const missing = [];
-        const frameworkDir = getFrameworkDir(projectRoot);
-        const checkPaths = [
-            { path: "apps/backend/src/types", type: "folder", optional: true },
-            { path: "apps/web/src/types", type: "folder", optional: true },
-            { path: "framework-mcp/src", type: "folder" },
-            { path: ".env", type: "file", optional: true },
-            { path: ".env.example", type: "file" },
-            { path: path.join(frameworkDir, "PROJECT_MEMORY.md"), type: "file" },
-            { path: path.join(frameworkDir, "BRAIN_DASHBOARD.md"), type: "file" },
-            { path: "docs/README.md", type: "file" },
-            { path: "docs/getting-started.md", type: "file" },
-            { path: "docs/architecture/approval-flows.md", type: "file", optional: true },
-            { path: "docs/backend/error-handling.md", type: "file", optional: true },
-            { path: "docs/frontend/component-patterns.md", type: "file", optional: true },
-        ];
-        for (const item of checkPaths) {
-            const fullPath = path.join(projectRoot, item.path);
-            if (!fs.existsSync(fullPath) && !item.optional) {
-                missing.push(`[MISSING ${item.type.toUpperCase()}] ${item.path}`);
-            }
-        }
-        const agentsDir = path.join(projectRoot, frameworkDir, "agents");
-        if (!fs.existsSync(agentsDir)) {
-            missing.push(`[MISSING FOLDER] ${frameworkDir}/agents`);
-        }
-        else {
-            const agents = fs.readdirSync(agentsDir)
-                .filter((f) => f.endsWith(".md") && f !== "README.md")
-                .map((f) => f.replace(".md", ""));
-            const logsDir = path.join(projectRoot, frameworkDir, "logs");
-            for (const agentName of agents) {
-                const logFile = path.join(logsDir, `${agentName}.json`);
-                if (!fs.existsSync(logFile)) {
-                    missing.push(`[MISSING LOG FILE] ${frameworkDir}/logs/${agentName}.json (Expected for agent ${agentName})`);
-                }
-            }
-            // v1.0 Army infrastructure checks
-            const v1Dirs = [
-                path.join(projectRoot, frameworkDir, "memory-graph"),
-                path.join(projectRoot, frameworkDir, "memory-graph", "agent-contexts"),
-                path.join(projectRoot, frameworkDir, "queue"),
-                path.join(projectRoot, frameworkDir, "agents", "schema"),
-            ];
-            for (const d of v1Dirs) {
-                if (!fs.existsSync(d)) {
-                    missing.push(`[MISSING v1.0 DIR] ${path.relative(projectRoot, d)}`);
-                }
-            }
-        }
-        return { content: [{ type: "text", text: missing.length > 0 ? `Detected Gaps:\n${missing.join("\n")}` : "No structural gaps detected based on core standards." }] };
-    },
-    get_memory_insights: async (args, projectRoot) => {
-        try {
-            const frameworkDir = getFrameworkDir(projectRoot);
-            const memoryPath = path.join(projectRoot, frameworkDir, "PROJECT_MEMORY.md");
-            const dashboardPath = path.join(projectRoot, frameworkDir, "BRAIN_DASHBOARD.md");
-            const memory = fs.existsSync(memoryPath) ? fs.readFileSync(memoryPath, "utf-8") : "Memory file missing.";
-            const dashboard = fs.existsSync(dashboardPath) ? fs.readFileSync(dashboardPath, "utf-8") : "Dashboard file missing.";
-            const history = memory.split("## HISTORY")[1] || "No history found.";
-            const activeTasks = memory.split("## ACTIVE TASKS")[1]?.split("##")[0] || "No active tasks.";
-            const dashboardAgents = dashboard.split("## 📈 Visualizations")[0] || dashboard;
-            return {
-                content: [{ type: "text", text: `### LIVE MEMORY INSIGHTS\n\n**Active Tasks:**\n${activeTasks.trim()}\n\n**Recent History:**\n${history.trim().substring(0, 1000)}...\n\n**Brain Snapshot:**\n${dashboardAgents.trim().substring(0, 500)}...` }],
-            };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Failed to get memory insights." }] };
-        }
-    },
-    codebase_context: async (args, projectRoot) => {
-        try {
-            const artifacts = collectMarkdownArtifacts(projectRoot);
-            const frameworkDir = getFrameworkDir(projectRoot);
-            const memoryPath = path.join(projectRoot, frameworkDir, "PROJECT_MEMORY.md");
-            const dashboardPath = path.join(projectRoot, frameworkDir, "BRAIN_DASHBOARD.md");
-            return {
-                content: [{ type: "text", text: "### CONTEXT ARTIFACTS\n\n" + `PROJECT_MEMORY: ${fs.existsSync(memoryPath) ? "present" : "missing"}\n` + `BRAIN_DASHBOARD: ${fs.existsSync(dashboardPath) ? "present" : "missing"}\n` + `Docs:\n${artifacts.length > 0 ? artifacts.join("\n") : "No markdown artifacts found."}` }],
-            };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Failed to gather codebase context." }] };
-        }
-    },
-    get_system_time: async () => {
-        return { content: [{ type: "text", text: new Date().toISOString() }] };
-    },
-    verify_framework_health: async (args, projectRoot) => {
-        try {
-            const frameworkDir = getFrameworkDir(projectRoot);
-            const requiredFiles = [
-                ["Constitution", fs.existsSync(path.join(projectRoot, "ENDERUN.md")) ? "ENDERUN.md" : path.join(frameworkDir, "ENDERUN.md")],
-                ["Memory", path.join(frameworkDir, "PROJECT_MEMORY.md")],
-                ["Command Map", path.join(frameworkDir, "cli-commands.json")],
-                ["Framework Config", path.join(frameworkDir, "config.json")],
-                ["Agent Status", path.join(frameworkDir, "STATUS.md")],
-                ["MCP Config", "mcp.json"],
-                ["Backend Contract", "apps/backend/contract.version.json"],
-                ["MCP Server", "framework-mcp/package.json"],
-                ["Panda CSS Config", "panda.config.ts"],
-                ["Brain Dashboard", path.join(frameworkDir, "BRAIN_DASHBOARD.md")],
-                ["Docs Portal", "docs/README.md"],
-                ["Getting Started", "docs/getting-started.md"],
-            ];
-            const lines = [];
-            let issues = 0;
-            for (const [name, relativePath] of requiredFiles) {
-                if (fs.existsSync(path.join(projectRoot, relativePath))) {
-                    lines.push(`OK ${name}: ${relativePath}`);
-                }
-                else {
-                    issues += 1;
-                    lines.push(`MISSING ${name}: ${relativePath}`);
-                }
-            }
-            const buildPath = path.join(projectRoot, "framework-mcp/dist/index.js");
-            if (fs.existsSync(buildPath)) {
-                lines.push("OK MCP Build: framework-mcp/dist/index.js");
-            }
-            else {
-                issues += 1;
-                lines.push("MISSING MCP Build: framework-mcp/dist/index.js");
-            }
-            const status = issues === 0 ? "PASSED" : "FAILED";
-            return { content: [{ type: "text", text: `### FRAMEWORK HEALTH CHECK (${status})\n\n${lines.join("\n")}` }] };
-        }
-        catch (error) {
-            const err = error;
-            return { content: [{ type: "text", text: `### FRAMEWORK HEALTH CHECK (FAILED)\n\n${err.message ?? "Unknown error"}` }] };
-        }
-    }
-};

package/framework-mcp/dist/tools/git.js

@@ -1,51 +0,0 @@
-import path from "path";
-import { execSync } from "child_process";
-import { GENERATE_SEMANTIC_COMMIT_MESSAGE_ARGS_SCHEMA } from "../schemas.js";
-export const gitTools = [
-    {
-        name: "generate_semantic_commit_message",
-        description: "Analyzes staged git changes and generates a structured semantic commit message based on project standards.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                traceId: { type: "string", description: "The active Trace ID (ULID)" },
-            },
-            required: ["traceId"],
-        },
-    },
-];
-export const gitHandlers = {
-    generate_semantic_commit_message: async (args, projectRoot) => {
-        const parsed = GENERATE_SEMANTIC_COMMIT_MESSAGE_ARGS_SCHEMA.safeParse(args ?? {});
-        if (!parsed.success)
-            return { content: [{ type: "text", text: "Invalid traceId argument." }] };
-        try {
-            const diff = execSync("git diff --staged", { encoding: "utf-8", cwd: projectRoot });
-            if (!diff)
-                return { content: [{ type: "text", text: "No staged changes found." }] };
-            const files = execSync("git diff --staged --name-only", { encoding: "utf-8", cwd: projectRoot }).split("\n").filter(Boolean);
-            let type = "feat", scope = "code";
-            if (files.some(f => f.includes(".md")))
-                type = "docs";
-            else if (files.some(f => f.includes("apps/backend/src/types")))
-                type = "arch";
-            else if (files.some(f => f.includes("framework-mcp")))
-                type = "chore";
-            else if (files.some(f => f.includes("bin/cli.js")))
-                type = "fix";
-            else if (files.some(f => f.includes("test")))
-                type = "test";
-            if (files.some(f => f.includes("apps/web")))
-                scope = "web";
-            else if (files.some(f => f.includes("apps/backend")))
-                scope = "backend";
-            else if (files.some(f => f.includes("framework-mcp")))
-                scope = "mcp";
-            const summary = files.length === 1 ? `update ${path.basename(files[0])}` : `update ${files.length} files`;
-            return { content: [{ type: "text", text: `### SUGGESTED SEMANTIC COMMIT MESSAGE\n\n\`[${parsed.data.traceId}] ${type}(${scope}): ${summary}\`\n\n**Files Analyzed:**\n${files.map(f => `- ${f}`).join("\n")}` }] };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Failed to generate semantic commit message." }] };
-        }
-    },
-};