agent-enderun 0.8.8 → 0.9.1

package/docs/roadmap.md

@@ -1,142 +0,0 @@
-# Agent Enderun — Development Roadmap (v0.6.6+) / Geliştirme Yol Haritası
-
-**Last Updated / Son Güncelleme:** 23 May 2026 / 23 May 2026  
-**Owner / Sorumlu:** @manager
-
-[English](#english) | [Türkçe](#türkçe)
-
----
-
-# English
-
-This document outlines the development roadmap for the Agent Enderun framework **v0.6.6 and beyond**. All items are prioritized logically based on actual project needs and corporate governance principles.
-
-## Current Status (24 May 2026)
-
-- **Version:** v0.6.6 (ready for npm release)
-- **System Health:** 🟢 GREEN
-- **Key Accomplishments:**
-  - Only Gemini adapter supported (installs to .enderun/)
-  - Antigravity adapter and all related code fully removed
-  - Lint technical debt resolved (reduced from 43 to 0 issues)
-  - Published `docs/getting-started.md` guide
-  - Updated memory structures and workspace hygiene
-
-- **Active Challenge:** Memory and task tracking need reinforcement (ACTIVE TASKS section is empty)
-
----
-
-## Agent Maturity & Professionalization Program (Highest Strategic Initiative)
-
-To make Agent Enderun truly production-grade for enterprise use, agents must be professionalized to meet the standards of senior software engineers.
-
-This program systematically audits current agent maturity levels and runs structured improvements to elevate each agent to enterprise readiness.
-
-### Agent Maturity Targets
-
-| Agent Persona | Current Level | Target Level | Priority / Risk Status |
-| :--- | :--- | :--- | :--- |
-| **@manager** | 8.0 | 9.5 | High / Stable. Leadership and project management capabilities are excellent. |
-| **@backend** | 7.5 | 9.0 | High / Stable. Deeply understands Kysely and Fastify patterns; testing discipline needs reinforcement. |
-| **@frontend** | 6.5 | 9.0 | **Critical / High Risk**. Needs major reinforcement in component slots, composition patterns, WCAG 2.2 accessibility, and performance engineering. |
-| **@explorer** | 6.5 | 8.5 | High / Stable. Highly capable in dependency analysis and codebase intelligence. |
-| **@analyst** | 6.5 | 8.5 | Medium / Stable. Handles system health metrics and compliance audits. |
-| **@git** | 6.0 | 8.0 | Medium / Stable. Coordinates PRs, semantic commits, and version compliance. |
-| **@mobile** | 2.0 | 7.5 | Low / Dormant. Foundational blueprints and Hermes safety rules added. |
-
-> **Note:** `@frontend` is currently the highest risk to enterprise onboarding and is the top priority.
-
----
-
-## Roadmap Overview
-
-| Phase | Timeline | Focus | Priority |
-| :--- | :--- | :--- | :--- |
-| **Agent Maturity Program** | 1–4 Months | Elevate all agents to professional enterprise-grade | **Highest** |
-| **Phase 1** | 1–6 Weeks | Usability, automated configurations, and CLI tooling | High |
-| **Phase 2** | 1–3 Months | Hermes messaging stability & multi-agent intelligence | High |
-| **Phase 3** | 3+ Months | Scalability, performance benchmarks, and Reference Application | Medium |
-
----
-
-## Agent Maturity Program — Phase 1 (Weeks 1–8)
-
-### 1. Professionalize @frontend Agent (Critical)
-- Component Architecture (Compound Components, Slots, Composition Patterns)
-- Accessibility (WCAG 2.2 AA compliance standards)
-- Performance Engineering (Core Web Vitals, virtualization, code splitting)
-- Testing Strategy (Hook + Component + Integration testing)
-- Error Boundaries & Resilience
-- Design System Governance
-
-### 2. Reinforce @backend Agent
-- Production Testing Culture (Unit + Integration + Contract + E2E)
-- Observability (Structured Logging + Metrics + Tracing)
-- Resilience Patterns (Idempotency, Retry, Circuit Breaker)
-- Query Optimization and Caching Strategy
-
-### 3. Elevate @manager Leadership
-- Technical Debt Auditing & Escalation Register
-- Risk Assessment Framework
-- Capacity Planning & Sustainable Delivery
-- Architecture Decision Records (ADR) Discipline
-
----
-
-## Phase 1 — Short-Term (Weeks 1–6)
-
-### 1. Fully Automate Claude Configuration
-- **Description:** Remove the manual `claude config add` step after running `init claude`. Automatically patch the Claude Desktop configuration file.
-- **Complexity:** Medium
-- **Status:** Pending
-
-### 2. Frontend Blueprint System
-- **Description:** Carry the blueprint generator power of the backend over to the frontend. Establish structured React components, pages, and UI pattern blueprints.
-- **Complexity:** Medium-High
-- **Status:** Pending
-
-### 3. Expand Getting Started Documentation
-- **Description:** Enrich the new guide based on developer feedback. Add more real-world scenarios, troubleshooting tips, and best practices.
-- **Complexity:** Low-Medium
-- **Status:** In Progress (Getting started guide updated to v0.6.6)
-
----
-
-## Phase 2 — Mid-Term (Months 1–3)
-
-### 4. Fully Implement Hermes Messaging Protocol
-- **Description:** Move inter-agent categorized, prioritized, and persistent messaging protocol from "defined on paper" to active code implementation.
-- **Complexity:** High
-- **Status:** Draft defined; implementation pending
-
-### 5. Reinforce Academy & Performance System
-- **Description:** Aggregate success metrics, failure tracking, and structured feedback for all agents to report via dashboard.
-- **Complexity:** Medium-High
-- **Status:** Basic tools available; scaling required
-
----
-
-## Phase 3 — Long-Term (Months 3+)
-
-### 6. Production-Grade Reference Application
-- **Description:** Build a complete end-to-end reference application demonstrating normal CRUD + High-Risk Admin actions + Hermes messaging under Agent Enderun's governance.
-- **Complexity:** Very High
-- **Status:** Planned
-
----
-
-# Türkçe
-
-Bu belge, Agent Enderun framework’ünün **v0.6.6 sonrası** geliştirme yol haritasını içerir.
-
-## Mevcut Durum (May 2026)
-
-- **Versiyon:** v0.6.6
-- **Sistem Sağlığı:** 🟢 GREEN (build ve test altyapısı onarım altında)
-- **v0.6.6 Odak:** Tüm framework’ün profesyonel İngilizceye dönüştürülmesi ve yönetişim boşluklarının dürüstçe analiz edilmesi.
-
-## Özet
-
-Ajan Olgunluk Programı devam etmektedir. @frontend en yüksek riskli ajan olmaya devam ediyor. Hermes protokolünün canlı test edilmesi ve referans uygulamanın üretilmesi önümüzdeki ana hedeflerdir.
-
-Detaylı plan ve risk takibi İngilizce bölümde yer almaktadır.

package/framework-mcp/README.md

@@ -1,55 +0,0 @@
-# AI-Enderun MCP Server (v0.8.3)
-
-English | [Türkçe](#türkçe)
-
-The `ai-enderun-mcp` package is the core intelligence engine of the Agent Enderun framework, implementing the Model Context Protocol (MCP).
-
-## English
-
-### 🛠️ Categorized Tools
-
-#### 🛡️ Security & Compliance
-- `security_audit_scan`: Scans for secrets, raw SQL, and unsafe patterns using AST.
-- `analyze_constitution_compliance`: Verifies adherence to `ENDERUN.md` rules.
-
-#### 🧠 Framework & Memory
-- `get_framework_status`: Retrieves active phase and status.
-- `update_project_memory`: Atomic updates to project brain sections.
-- `bootstrap_legacy_memory`: Auto-generates memory for existing projects.
-- `read_project_memory`: Safe read access to the project brain.
-
-#### 🔍 Codebase Intelligence
-- `search_codebase`: Regex-powered semantic search.
-- `analyze_dependencies`: Deep import tracking and dependency mapping.
-- `analyze_codebase_intelligence`: Detects complexity spikes and dead code.
-- `generate_dependency_graph`: Creates Mermaid architecture maps.
-
-#### 📜 Contract Management
-- `verify_api_contract`: Checks shared-types integrity via hashing.
-- `update_contract_hash`: Synchronizes the contract versioning.
-- `verify_contract_integrity`: Ensures API docs and types are in sync.
-
-#### 🎓 Academy & Orchestration
-- `log_agent_action`: Records traceable agent activities.
-- `send_agent_message`: Facilitates inter-agent collaboration.
-- `read_agent_messages`: Inbox management for specialized agents.
-
-#### 📦 Repository & Git
-- `generate_semantic_commit_message`: Automated commit messages based on diffs.
-
----
-
-## Türkçe
-
-### 🛠️ Kategorize Edilmiş Araçlar
-
-- **Güvenlik:** `security_audit_scan`, `analyze_constitution_compliance`.
-- **Hafıza:** `get_framework_status`, `update_project_memory`, `bootstrap_legacy_memory`.
-- **Zeka:** `search_codebase`, `analyze_dependencies`, `generate_dependency_graph`.
-- **Kontrat:** `verify_api_contract`, `update_contract_hash`, `verify_contract_integrity`.
-- **Orkestrasyon:** `send_agent_message`, `log_agent_action`.
-- **Repo:** `generate_semantic_commit_message`.
-
-## License
-
-MIT

package/framework-mcp/dist/schemas.js

@@ -1,84 +0,0 @@
-import { z } from "zod";
-export const SECURITY_AUDIT_ARGS_SCHEMA = z.object({
-    path: z.string().default("."),
-});
-export const SEARCH_CODEBASE_ARGS_SCHEMA = z.object({
-    query: z.string().min(1).max(300),
-    extension: z
-        .string()
-        .default("ts")
-        .refine((s) => /^[a-z0-9]+$/i.test(s), { message: "extension must be alphanumeric" }),
-});
-export const UPDATE_MEMORY_ARGS_SCHEMA = z.object({
-    section: z.enum(["CURRENT STATUS", "HISTORY", "ACTIVE TASKS"]),
-    content: z.string().min(1),
-});
-export const ANALYZE_DEPENDENCIES_ARGS_SCHEMA = z.object({
-    path: z.string().min(1),
-});
-export const LOG_AGENT_ACTION_ARGS_SCHEMA = z.object({
-    agent: z.string().min(1),
-    action: z.string().min(1),
-    requestId: z.string().min(1),
-    files: z.array(z.string()).default([]),
-    status: z.enum(["SUCCESS", "FAILURE"]),
-    summary: z.string().min(1),
-    details: z.record(z.string(), z.any()).default({}),
-});
-export const SEND_AGENT_MESSAGE_ARGS_SCHEMA = z.object({
-    from: z.string().min(1),
-    to: z.string().min(1),
-    message: z.string().min(1),
-    traceId: z.string().min(1),
-    category: z.enum(["ACTION", "DELEGATION", "INFO", "ALERT"]).default("INFO"),
-    priority: z.enum(["LOW", "MEDIUM", "HIGH", "URGENT"]).default("MEDIUM"),
-});
-export const UPDATE_AGENT_MESSAGE_STATUS_ARGS_SCHEMA = z.object({
-    agent: z.string().min(1),
-    traceId: z.string().min(1),
-    newStatus: z.enum(["ACKNOWLEDGED", "COMPLETED", "REJECTED"]),
-});
-export const SEARCH_KNOWLEDGE_BASE_ARGS_SCHEMA = z.object({
-    query: z.string().min(1),
-});
-export const UPDATE_KNOWLEDGE_BASE_ARGS_SCHEMA = z.object({
-    topic: z.string().min(1),
-    content: z.string().min(1),
-    tags: z.array(z.string().min(1)).default([]),
-});
-export const ANALYZE_CONSTITUTION_COMPLIANCE_ARGS_SCHEMA = z.object({
-    path: z.string().min(1),
-});
-export const GENERATE_DEPENDENCY_GRAPH_ARGS_SCHEMA = z.object({
-    path: z.string().default("src"),
-    format: z.enum(["mermaid", "json"]).default("mermaid"),
-});
-export const READ_AGENT_MESSAGES_ARGS_SCHEMA = z.object({
-    agent: z.string().min(1),
-    traceId: z.string().min(1).optional(),
-});
-export const VERIFY_CONTRACT_INTEGRITY_ARGS_SCHEMA = z.object({
-    domain: z.string().min(1),
-});
-export const GENERATE_SEMANTIC_COMMIT_MESSAGE_ARGS_SCHEMA = z.object({
-    traceId: z.string().min(1),
-});
-export const ANALYZE_CODEBASE_INTELLIGENCE_ARGS_SCHEMA = z.object({
-    path: z.string().default("."),
-});
-export const ANALYZE_PROCEDURAL_CONTINUITY_ARGS_SCHEMA = z.object({
-    targetPath: z.string().min(1),
-    referencePath: z.string().min(1),
-});
-export const GET_AGENT_INBOX_STATS_ARGS_SCHEMA = z.object({
-    agent: z.string().min(1),
-});
-export const GET_KNOWLEDGE_GRAPH_ARGS_SCHEMA = z.object({
-    tag: z.string().optional(),
-});
-export const SYNC_CONTRACT_HASH_ARGS_SCHEMA = z.object({
-    force: z.boolean().default(false),
-});
-export const VERIFY_FRAMEWORK_HEALTH_ARGS_SCHEMA = z.object({
-    detailed: z.boolean().default(false),
-});

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

@@ -1,294 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { Project } from "ts-morph";
-import { collectFilesRecursively, resolveSafePath } from "../utils.js";
-import { SEARCH_CODEBASE_ARGS_SCHEMA, ANALYZE_DEPENDENCIES_ARGS_SCHEMA, ANALYZE_CODEBASE_INTELLIGENCE_ARGS_SCHEMA, ANALYZE_PROCEDURAL_CONTINUITY_ARGS_SCHEMA, GENERATE_DEPENDENCY_GRAPH_ARGS_SCHEMA } from "../schemas.js";
-export const codebaseTools = [
-    {
-        name: "search_codebase",
-        description: "Semantic search across the codebase using grep for exact matches and context. Ideal for finding logic and patterns.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                query: {
-                    type: "string",
-                    description: "Search query or regex pattern",
-                },
-                extension: {
-                    type: "string",
-                    description: "File extension filter (e.g., ts, md)",
-                    default: "ts",
-                },
-            },
-            required: ["query"],
-        },
-    },
-    {
-        name: "codebase_search",
-        description: "Compatibility alias for search_codebase. Use when older agent prompts still reference codebase_search.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                query: {
-                    type: "string",
-                    description: "Search query or regex pattern",
-                },
-                extension: {
-                    type: "string",
-                    description: "File extension filter (e.g., ts, md)",
-                    default: "ts",
-                },
-            },
-            required: ["query"],
-        },
-    },
-    {
-        name: "analyze_dependencies",
-        description: "Analyze code dependencies for a specific file or folder using import tracking.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: {
-                    type: "string",
-                    description: "Path to analyze (relative to project root)",
-                },
-            },
-            required: ["path"],
-        },
-    },
-    {
-        name: "codebase_graph_query",
-        description: "Compatibility alias for analyze_dependencies. Returns import-level dependency information for a file or folder.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: {
-                    type: "string",
-                    description: "Path to analyze (relative to project root)",
-                },
-            },
-            required: ["path"],
-        },
-    },
-    {
-        name: "analyze_codebase_intelligence",
-        description: "Scans the codebase for complexity spikes and potential dead code (exported but unused symbols).",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: {
-                    type: "string",
-                    description: "Path to scan (relative to project root)",
-                    default: ".",
-                },
-            },
-        },
-    },
-    {
-        name: "analyze_procedural_continuity",
-        description: "Compares a target file with a reference file to identify stylistic or structural deviations. Ensures agents follow existing patterns.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                targetPath: {
-                    type: "string",
-                    description: "Path to the newly created/modified file",
-                },
-                referencePath: {
-                    type: "string",
-                    description: "Path to an existing 'gold standard' file for comparison",
-                },
-            },
-            required: ["targetPath", "referencePath"],
-        },
-    },
-    {
-        name: "generate_dependency_graph",
-        description: "Generates a Mermaid-compatible dependency graph of the codebase or a specific directory.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                path: {
-                    type: "string",
-                    description: "Path to scan (relative to project root)",
-                    default: "src",
-                },
-                format: {
-                    type: "string",
-                    enum: ["mermaid", "json"],
-                    default: "mermaid",
-                },
-            },
-        },
-    },
-];
-export const codebaseHandlers = {
-    search_codebase: async (args, projectRoot) => {
-        const parsed = SEARCH_CODEBASE_ARGS_SCHEMA.safeParse(args);
-        if (!parsed.success) {
-            return { content: [{ type: "text", text: "Invalid query/extension argument." }] };
-        }
-        const { query, extension } = parsed.data;
-        try {
-            const files = collectFilesRecursively(projectRoot, new Set([extension]));
-            let queryRegex;
-            try {
-                queryRegex = new RegExp(query, "i");
-            }
-            catch {
-                return { content: [{ type: "text", text: "Invalid regex pattern in query." }] };
-            }
-            const matches = [];
-            const MAX_RESULTS = 30;
-            for (const filePath of files) {
-                if (matches.length >= MAX_RESULTS)
-                    break;
-                const content = fs.readFileSync(filePath, "utf-8");
-                const lines = content.split("\n");
-                for (let i = 0; i < lines.length; i++) {
-                    if (matches.length >= MAX_RESULTS)
-                        break;
-                    const line = lines[i];
-                    if (queryRegex.test(line)) {
-                        const relativePath = path.relative(projectRoot, filePath);
-                        matches.push(`- ${relativePath}:${i + 1}: ${line.trim()}`);
-                    }
-                }
-            }
-            return { content: [{ type: "text", text: matches.join("\n") || "No matches found." }] };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Search failed." }] };
-        }
-    },
-    analyze_dependencies: async (args, projectRoot) => {
-        const parsed = ANALYZE_DEPENDENCIES_ARGS_SCHEMA.safeParse(args);
-        if (!parsed.success) {
-            return { content: [{ type: "text", text: "Invalid path argument." }] };
-        }
-        const targetPath = parsed.data.path;
-        try {
-            const fullPath = resolveSafePath(projectRoot, targetPath);
-            if (!fs.existsSync(fullPath))
-                return { content: [{ type: "text", text: `Path not found: ${targetPath}` }] };
-            const stats = fs.statSync(fullPath);
-            const tsProject = new Project({ compilerOptions: { allowJs: true } });
-            if (stats.isDirectory()) {
-                tsProject.addSourceFilesAtPaths(path.join(fullPath, "**/*.{ts,tsx,js,jsx}"));
-                const sourceFiles = tsProject.getSourceFiles();
-                return { content: [{ type: "text", text: `Directory contains ${sourceFiles.length} source files. Use a specific file path for deep dependency analysis.` }] };
-            }
-            else {
-                const sourceFile = tsProject.addSourceFileAtPath(fullPath);
-                const imports = sourceFile.getImportDeclarations();
-                const importDetails = imports.map((imp) => {
-                    const moduleSpecifier = imp.getModuleSpecifierValue();
-                    const source = imp.getModuleSpecifierSourceFile();
-                    const resolvedPath = source ? path.relative(projectRoot, source.getFilePath()) : "unresolved/external";
-                    return `- ${moduleSpecifier} (${resolvedPath})`;
-                });
-                return { content: [{ type: "text", text: `Dependencies for ${targetPath}:\n${importDetails.length > 0 ? importDetails.join("\n") : "No imports found."}` }] };
-            }
-        }
-        catch (error) {
-            return { content: [{ type: "text", text: "Analysis failed: " + (error instanceof Error ? error.message : String(error)) }] };
-        }
-    },
-    analyze_codebase_intelligence: async (args, projectRoot) => {
-        const parsed = ANALYZE_CODEBASE_INTELLIGENCE_ARGS_SCHEMA.safeParse(args);
-        const targetPath = parsed.success ? parsed.data.path : ".";
-        try {
-            const safeTargetPath = resolveSafePath(projectRoot, targetPath);
-            if (!fs.existsSync(safeTargetPath))
-                return { content: [{ type: "text", text: "Target path not found." }] };
-            const tsProject = new Project({ compilerOptions: { allowJs: true } });
-            tsProject.addSourceFilesAtPaths(path.join(safeTargetPath, "**/*.{ts,tsx}"));
-            const complexitySpikes = [];
-            const potentialDeadCode = [];
-            for (const sourceFile of tsProject.getSourceFiles()) {
-                const relativePath = path.relative(projectRoot, sourceFile.getFilePath());
-                const lineCount = sourceFile.getEndLineNumber();
-                if (lineCount > 300)
-                    complexitySpikes.push(`${relativePath} (${lineCount} lines)`);
-                sourceFile.getExportedDeclarations().forEach((declarations, name) => {
-                    const isUsed = tsProject.getSourceFiles().some(sf => {
-                        if (sf === sourceFile)
-                            return false;
-                        return sf.getImportDeclarations().some(i => i.getModuleSpecifierValue().includes(sourceFile.getBaseNameWithoutExtension()) && i.getNamedImports().some(ni => ni.getName() === name));
-                    });
-                    if (!isUsed && !sourceFile.getFilePath().includes("index.ts") && !sourceFile.getFilePath().includes("shared-types")) {
-                        potentialDeadCode.push(`${relativePath} -> ${name}`);
-                    }
-                });
-            }
-            return { content: [{ type: "text", text: `### CODEBASE INTELLIGENCE REPORT\n\n**Complexity Spikes (>300 lines):**\n${complexitySpikes.length > 0 ? complexitySpikes.map(s => `- ${s}`).join("\n") : "- None detected"}\n\n**Potential Dead Code (Unused Exports):**\n${potentialDeadCode.length > 0 ? potentialDeadCode.map(d => `- ${d}`).join("\n") : "- None detected (within scanned scope)"}` }] };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Intelligence scan failed." }] };
-        }
-    },
-    analyze_procedural_continuity: async (args, projectRoot) => {
-        const parsed = ANALYZE_PROCEDURAL_CONTINUITY_ARGS_SCHEMA.safeParse(args);
-        if (!parsed.success)
-            return { content: [{ type: "text", text: "Invalid targetPath or referencePath." }] };
-        try {
-            const targetFull = resolveSafePath(projectRoot, parsed.data.targetPath);
-            const referenceFull = resolveSafePath(projectRoot, parsed.data.referencePath);
-            if (!fs.existsSync(targetFull) || !fs.existsSync(referenceFull))
-                return { content: [{ type: "text", text: "One or both files not found." }] };
-            const tsProject = new Project({ compilerOptions: { allowJs: true } });
-            const targetFile = tsProject.addSourceFileAtPath(targetFull);
-            const referenceFile = tsProject.addSourceFileAtPath(referenceFull);
-            const deviations = [];
-            const targetImports = targetFile.getImportDeclarations().map(i => i.getModuleSpecifierValue());
-            const referenceImports = referenceFile.getImportDeclarations().map(i => i.getModuleSpecifierValue());
-            const missingImports = referenceImports.filter(i => !targetImports.includes(i) && !i.startsWith("."));
-            if (missingImports.length > 0)
-                deviations.push(`Missing standard imports found in reference: ${missingImports.join(", ")}`);
-            if (referenceFile.getClasses().length > 0 && targetFile.getClasses().length === 0)
-                deviations.push("Reference uses classes, but target does not.");
-            const targetFunctions = targetFile.getFunctions().map(f => f.getName());
-            const referenceFunctions = referenceFile.getFunctions().map(f => f.getName());
-            if (referenceFunctions.some(f => f?.startsWith("get")) && !targetFunctions.some(f => f?.startsWith("get")))
-                deviations.push("Reference uses 'get' prefix for functions, target does not.");
-            return { content: [{ type: "text", text: deviations.length > 0 ? `### PROCEDURAL CONTINUITY DEVIATIONS\n\n${deviations.map(d => `- ${d}`).join("\n")}` : "No major structural or stylistic deviations detected based on reference." }] };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Dependency analysis failed." }] };
-        }
-    },
-    generate_dependency_graph: async (args, projectRoot) => {
-        const parsed = GENERATE_DEPENDENCY_GRAPH_ARGS_SCHEMA.safeParse(args);
-        const targetPath = parsed.success ? parsed.data.path : "src";
-        const format = parsed.success ? parsed.data.format : "mermaid";
-        try {
-            const safeTargetPath = resolveSafePath(projectRoot, targetPath);
-            if (!fs.existsSync(safeTargetPath))
-                return { content: [{ type: "text", text: "Target path not found." }] };
-            const tsProject = new Project({ compilerOptions: { allowJs: true } });
-            tsProject.addSourceFilesAtPaths(path.join(safeTargetPath, "**/*.{ts,tsx}"));
-            const edges = [];
-            for (const sourceFile of tsProject.getSourceFiles()) {
-                const from = sourceFile.getBaseNameWithoutExtension();
-                sourceFile.getImportDeclarations().forEach(imp => {
-                    const moduleSpecifier = imp.getModuleSpecifierValue();
-                    if (moduleSpecifier.startsWith(".")) {
-                        const to = path.basename(moduleSpecifier, path.extname(moduleSpecifier));
-                        edges.push({ from, to });
-                    }
-                });
-            }
-            if (format === "json")
-                return { content: [{ type: "text", text: JSON.stringify(edges, null, 2) }] };
-            let mermaid = "graph TD\n";
-            const uniqueEdges = Array.from(new Set(edges.map(e => `${e.from} --> ${e.to}`)));
-            if (uniqueEdges.length === 0)
-                return { content: [{ type: "text", text: "No internal dependencies found in the scanned path." }] };
-            mermaid += uniqueEdges.join("\n");
-            return { content: [{ type: "text", text: `### VISUAL ARCHITECTURE MAP: ${targetPath}\n\n\`\`\`mermaid\n${mermaid}\n\`\`\`\n\n**Total Nodes:** ${new Set(edges.flatMap(e => [e.from, e.to])).size} | **Total Edges:** ${uniqueEdges.length}` }] };
-        }
-        catch {
-            return { content: [{ type: "text", text: "Dependency graph generation failed." }] };
-        }
-    },
-};