atabey 0.0.5 → 0.0.7

package/framework-mcp/src/tools/types.ts

@@ -1,89 +0,0 @@
-export interface ToolDefinition {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: Record<string, unknown>;
-        required?: string[];
-    };
-}
-
-// ─── File System ────────────────────────────────────────────────
-export interface ReadFileArgs { path: string; startLine?: number; endLine?: number; }
-export interface WriteFileArgs { path: string; content: string; }
-export interface ReplaceTextArgs { path: string; oldText: string; newText: string; allowMultiple?: boolean; }
-export interface PatchFileArgs { path: string; startLine: number; endLine: number; newContent: string; }
-export interface BatchSurgicalEditArgs {
-    edits: Array<{ path: string; oldText: string; newText: string; allowMultiple?: boolean; }>;
-}
-
-// ─── Search & Discovery ──────────────────────────────────────────
-export interface ListDirArgs { path?: string; }
-export interface GrepSearchArgs { pattern: string; includePattern?: string; excludePattern?: string; }
-export interface GetProjectMapArgs { maxDepth?: number; includeFiles?: boolean; }
-export interface GetProjectGapsArgs { path?: string; }
-
-// ─── Messaging (Hermes) ─────────────────────────────────────────
-export interface SendAgentMessageArgs {
-    from: string;
-    to: string;
-    category: "ACTION" | "DELEGATION" | "SUBTASK" | "REPLY" | "ALERT";
-    content: string;
-    traceId: string;
-    parentId?: string;
-    priority?: "HIGH" | "NORMAL" | "LOW";
-    requiresApproval?: boolean;
-}
-export interface LogAgentActionArgs {
-    agent: string;
-    action: string;
-    traceId: string;
-    status: "SUCCESS" | "FAILURE";
-    summary: string;
-    findings?: string;
-}
-
-// ─── Control Plane ──────────────────────────────────────────────
-export interface AcquireLockArgs { resource: string; agent: string; ttl?: number; }
-export interface ReleaseLockArgs { resource: string; agent: string; }
-export interface RegisterAgentArgs { agent: string; role: string; capability?: number; }
-
-// ─── Observability & Utils ──────────────────────────────────────
-export interface StartDashboardArgs { port?: number; }
-export interface CheckActivePortsArgs { filter?: string; }
-export interface RunTestsArgs { command?: string; timeout?: number; }
-export interface UpdateProjectMemoryArgs { section: string; content: string; }
-export interface GetStatusArgs { timeout?: number; }
-export interface OrchestrateArgs { timeout?: number; }
-export interface UpdateContractHashArgs { timeout?: number; }
-export interface RunCommandArgs { command: string; }
-
-export type ToolArgs =
-    | ReadFileArgs
-    | WriteFileArgs
-    | ReplaceTextArgs
-    | PatchFileArgs
-    | BatchSurgicalEditArgs
-    | ListDirArgs
-    | GrepSearchArgs
-    | GetProjectMapArgs
-    | GetProjectGapsArgs
-    | SendAgentMessageArgs
-    | LogAgentActionArgs
-    | AcquireLockArgs
-    | ReleaseLockArgs
-    | RegisterAgentArgs
-    | StartDashboardArgs
-    | CheckActivePortsArgs
-    | RunTestsArgs
-    | UpdateProjectMemoryArgs
-    | GetStatusArgs
-    | OrchestrateArgs
-    | UpdateContractHashArgs;
-
-export interface ToolResult {
-    isError?: boolean;
-    content: Array<{ type: "text"; text: string }>;
-}
-
-export type ToolHandler = (projectRoot: string, args: unknown) => ToolResult | Promise<ToolResult>;

package/framework-mcp/src/utils/cli.ts

@@ -1,53 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { execFileSync } from "child_process";
-
-/**
- * Executes a command safely and returns the output.
- */
-export function safeExec(cmd: string, args: string[], cwd: string, timeout = 30000): string {
-    try {
-        return execFileSync(cmd, args, { cwd, timeout, encoding: "utf8", stdio: "pipe" });
-    } catch (err: unknown) {
-        const error = err as { stdout?: Buffer | string; stderr?: Buffer | string; message?: string };
-        return error.stdout?.toString() || error.stderr?.toString() || error.message || String(err);
-    }
-}
-
-/**
- * Detects the backend language from the framework configuration.
- */
-export function getBackendLanguage(projectRoot: string): string {
-    try {
-        const configPath = path.join(projectRoot, ".atabey", "config.json");
-        if (fs.existsSync(configPath)) {
-            const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
-            return config.backendLanguage || "Node.js (TypeScript)";
-        }
-    } catch {
-        // Fallback to default
-    }
-    return "Node.js (TypeScript)";
-}
-
-/**
- * Returns the default lint command for the given language.
- */
-export function getDefaultLintCommand(language: string): string {
-    if (language.includes("Go")) return "go fmt ./...";
-    if (language.includes("Java")) return "./gradlew check"; // or mvn check
-    if (language.includes("Python")) return "ruff check .";
-    if (language.includes(".NET")) return "dotnet format";
-    return "npm run lint";
-}
-
-/**
- * Returns the default test command for the given language.
- */
-export function getDefaultTestCommand(language: string): string {
-    if (language.includes("Go")) return "go test ./...";
-    if (language.includes("Java")) return "./gradlew test"; // or mvn test
-    if (language.includes("Python")) return "pytest";
-    if (language.includes(".NET")) return "dotnet test";
-    return "npm test";
-}

package/framework-mcp/src/utils/compliance.ts

@@ -1,95 +0,0 @@
-import ts from "typescript";
-
-/**
- * Enterprise Compliance Guardrail
- * Checks content against corporate standards using AST analysis before allowing file mutations.
- */
-export function verifyCorporateCompliance(content: string, filePath: string): void {
-    // Skip compliance checks for non-source files or specific ignored files
-    if (filePath.endsWith(".json") || filePath.endsWith(".md") || filePath.endsWith(".env.example")) {
-        return;
-    }
-
-    const sourceFile = ts.createSourceFile(
-        filePath,
-        content,
-        ts.ScriptTarget.Latest,
-        true
-    );
-
-    const errors: string[] = [];
-
-    /**
-     * Recursive AST Visitor
-     */
-    function visit(node: ts.Node) {
-        // 1. Zero Console Policy
-        if (ts.isPropertyAccessExpression(node)) {
-            const expression = node.expression;
-            const name = node.name.text;
-            if (ts.isIdentifier(expression) && expression.text === "console") {
-                if (["log", "warn", "error"].includes(name)) {
-                    // Check if file is exempt
-                    if (!filePath.includes("logger.ts") && !filePath.includes("check.ts") && !filePath.includes("cli.ts")) {
-                        errors.push(`❌ Corporate Compliance Breach: 'console.${name}' usage is forbidden at line ${sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1}.`);
-                    }
-                }
-            }
-        }
-
-        // 2. No Explicit Any Policy
-        if (ts.isTypeReferenceNode(node)) {
-            if (ts.isIdentifier(node.typeName) && node.typeName.text === "any") {
-                if (!filePath.includes("definitions.ts") && !filePath.includes("types.ts")) {
-                    errors.push(`❌ Corporate Compliance Breach: 'any' type is forbidden at line ${sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1}.`);
-                }
-            }
-        }
-        
-        // 3. Zero UI Library Policy (No @chakra-ui, mui, @shadcn)
-        if (ts.isImportDeclaration(node)) {
-            const moduleSpecifier = node.moduleSpecifier;
-            if (ts.isStringLiteral(moduleSpecifier)) {
-                const forbiddenLibs = ["@chakra-ui", "mui", "@shadcn", "antd", "bootstrap"];
-                const lib = forbiddenLibs.find(l => moduleSpecifier.text.includes(l));
-                if (lib) {
-                    errors.push(`❌ Corporate Compliance Breach: External UI library '${lib}' usage is FORBIDDEN at line ${sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1}. Build atomic components manually instead.`);
-                }
-            }
-        }
-        
-        // Handle 'any' as a keyword type (e.g., parameter: any)
-        if (node.kind === ts.SyntaxKind.AnyKeyword) {
-            if (!filePath.includes("definitions.ts") && !filePath.includes("types.ts")) {
-                errors.push(`❌ Corporate Compliance Breach: 'any' keyword is forbidden at line ${sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1}.`);
-            }
-        }
-
-        ts.forEachChild(node, visit);
-    }
-
-    visit(sourceFile);
-
-    // 3. Hardcoded Secrets & PII Guard
-    const piiKeywords = [
-        { regex: /API_KEY\s*=\s*['"][^'"]+['"]/i, msg: "Hardcoded API Key" },
-        { regex: /SECRET\s*=\s*['"][^'"]+['"]/i, msg: "Hardcoded Secret" },
-        { regex: /PASSWORD\s*=\s*['"][^'"]+['"]/i, msg: "Hardcoded Password" },
-        { regex: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/, msg: "PII Detected: Email Address" },
-        { regex: /\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b/, msg: "PII Detected: Credit Card Pattern" }
-    ];
-    
-    for (const { regex, msg } of piiKeywords) {
-        if (regex.test(content)) {
-            // Allow emails in specific files like README or package.json
-            if (msg.includes("Email") && (filePath.endsWith("README.md") || filePath.endsWith("package.json") || filePath.includes("CONTRIBUTING"))) {
-                continue;
-            }
-            errors.push(`❌ Corporate Compliance Breach: ${msg} detected.`);
-        }
-    }
-
-    if (errors.length > 0) {
-        throw new Error(errors.join("\n"));
-    }
-}

package/framework-mcp/src/utils/fs.ts

@@ -1,45 +0,0 @@
-import fs from "fs";
-import path from "path";
-
-/**
- * Ensures directory existence.
- */
-export function ensureDir(dirPath: string): void {
-    if (!fs.existsSync(dirPath)) {
-        fs.mkdirSync(dirPath, { recursive: true });
-    }
-}
-
-/**
- * Atomically writes a text file.
- */
-export function writeTextFileAtomic(filePath: string, content: string): void {
-    const dir = path.dirname(filePath);
-    ensureDir(dir);
-
-    const tempPath = `${filePath}.${Math.random().toString(36).slice(2, 9)}.tmp`;
-    const finalContent = content.endsWith("\n") ? content : `${content}\n`;
-
-    try {
-        fs.writeFileSync(tempPath, finalContent, "utf8");
-        fs.renameSync(tempPath, filePath);
-    } catch (err) {
-        if (fs.existsSync(tempPath)) {
-            try { fs.unlinkSync(tempPath); } catch { /* ignore */ }
-        }
-        throw err;
-    }
-}
-
-/**
- * Atomically appends to a file (if supported by OS) or simulates it.
- * Note: Real atomic append on POSIX is a single write() call with O_APPEND.
- * For simplicity and robustness across platforms, we use a simple append here
- * as the risk of corruption is lower than a full rewrite, but for logs
- * it's acceptable.
- */
-export function appendFileSafe(filePath: string, content: string): void {
-    const dir = path.dirname(filePath);
-    ensureDir(dir);
-    fs.appendFileSync(filePath, content, "utf8");
-}

package/framework-mcp/src/utils/metrics.ts

@@ -1,73 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { resolveFrameworkDir } from "./security.js";
-/**
- * Token and Metric Tracker for Agent Atabey.
- * Estimates token usage and logs operational costs.
- */
-
-interface MetricEntry {
-    timestamp: string;
-    agent: string;
-    action: string;
-    estimatedTokens: number;
-    error?: string;
-}
-
-export const Metrics = {
-    /**
-     * Estimates tokens based on character count (rough heuristic: 1 token ~= 4 chars).
-     */
-    estimateTokens: (text: string): number => {
-        return Math.ceil(text.length / 4);
-    },
-
-    /**
-     * Logs the token usage and action to the observability metrics file.
-     */
-    logUsage: (projectRoot: string, agent: string, action: string, tokens: number) => {
-        Metrics.saveMetric(projectRoot, {
-            timestamp: new Date().toISOString(),
-            agent,
-            action,
-            estimatedTokens: tokens
-        });
-    },
-
-    /**
-     * Logs an error occurrence to the observability metrics file.
-     */
-    logError: (projectRoot: string, agent: string, action: string, error: string) => {
-        Metrics.saveMetric(projectRoot, {
-            timestamp: new Date().toISOString(),
-            agent,
-            action: `ERROR: ${action}`,
-            estimatedTokens: 0,
-            error
-        });
-    },
-
-    /**
-     * Internal helper to save metric entries.
-     */
-    saveMetric: (projectRoot: string, entry: MetricEntry) => {
-        const frameworkDir = resolveFrameworkDir(projectRoot);
-        const metricsPath = path.join(projectRoot, frameworkDir, "observability/metrics.json");
-        try {
-            const metricsDir = path.dirname(metricsPath);
-            if (!fs.existsSync(metricsDir)) fs.mkdirSync(metricsDir, { recursive: true });
-
-            let currentMetrics: MetricEntry[] = [];
-            if (fs.existsSync(metricsPath)) {
-                currentMetrics = JSON.parse(fs.readFileSync(metricsPath, "utf8"));
-            }
-
-            currentMetrics.push(entry);
-
-            // Keep only last 100 entries to save space
-            if (currentMetrics.length > 100) currentMetrics.shift();
-
-            fs.writeFileSync(metricsPath, JSON.stringify(currentMetrics, null, 2));
-        } catch { /* ignore: metrics should not block the main process */ }
-    }
-};

package/framework-mcp/src/utils/security.ts

@@ -1,66 +0,0 @@
-import path from "path";
-import fs from "fs";
-import { FRAMEWORK, MCP, UNIFIED_HUB_DIR } from "../constants.js"; // New import
-import os from "os"; // Need os.homedir()
-
-/**
- * Validates and resolves a user-provided path to prevent path traversal attacks.
- * Ensures the resolved path stays within the project root boundary.
- */
-export function safePath(projectRoot: string, userPath: string): string {
-    const resolved = path.resolve(projectRoot, userPath);
-    const normalizedRoot = path.resolve(projectRoot);
-
-    if (!resolved.startsWith(normalizedRoot + path.sep) && resolved !== normalizedRoot) {
-        throw new Error(`Access denied: path "${userPath}" escapes project root.`);
-    }
-
-    return resolved;
-}
-
-/**
- * Resolves the active framework directory.
- * Priority: ATABEY_TEST_DIR (env) -> package.json `atabey.frameworkDir` -> `.atabey` -> other adapter dirs -> global HOME.
- */
-export function resolveFrameworkDir(projectRoot: string): string {
-    // For test environments, use the explicitly set test directory.
-    const testDir = process.env[MCP.TEST_DIR_ENV];
-    if (testDir) return testDir;
-
-    // 1. Authoritative source: read from package.json if present
-    try {
-        const pkgPath = path.join(projectRoot, "package.json");
-        if (fs.existsSync(pkgPath)) {
-            const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8")) as Record<string, unknown>;
-            const atabeyConfig = pkg["atabey"] as Record<string, unknown> | undefined;
-            if (atabeyConfig && typeof atabeyConfig["frameworkDir"] === "string") {
-                // Ensure the path is relative if it's within the project, otherwise use as-is.
-                const resolvedDir = path.resolve(projectRoot, atabeyConfig["frameworkDir"]);
-                if (resolvedDir.startsWith(path.resolve(projectRoot))) {
-                    return path.relative(projectRoot, resolvedDir);
-                }
-                return atabeyConfig["frameworkDir"];
-            }
-        }
-    } catch {
-        // ignore — fall through to filesystem scan
-    }
-
-    // 2. Filesystem scan in projectRoot for common framework directories
-    const localCandidates = [
-        FRAMEWORK.CORE_DIR, // .atabey
-        UNIFIED_HUB_DIR,    // .agents
-        // Add other adapter specific directories if needed, or remove if unified is strictly enforced
-    ];
-
-    for (const candidate of localCandidates) {
-        const candidatePath = path.join(projectRoot, candidate);
-        if (fs.existsSync(candidatePath)) {
-            return candidate;
-        }
-    }
-
-    // 3. Fallback to global home directory.
-    const homeDir = os.homedir();
-    return path.join(homeDir, FRAMEWORK.CORE_DIR);
-}

package/framework-mcp/tests/tools/file_system/file_system_tools.test.ts

@@ -1,212 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import fs from "fs";
-import path from "path";
-import { handleReplaceText } from "../../../src/tools/file_system/replace_text.js";
-import { handlePatchFile } from "../../../src/tools/file_system/patch_file.js";
-import { handleReadFile } from "../../../src/tools/file_system/read_file.js";
-import { handleWriteFile } from "../../../src/tools/file_system/write_file.js";
-import { ToolArgs } from "../../../src/tools/types.js";
-
-import os from "os"; // Need to import os
-
-let TEST_DIR: string; // Declare as let
-let TEST_FILE: string;
-let MEMORY_DIR: string;
-let MEMORY_FILE: string;
-
-beforeEach(() => {
-    TEST_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "fs-tools-test-")); // Unique temp dir
-    fs.mkdirSync(path.join(TEST_DIR, ".atabey"));
-    TEST_FILE = path.join(TEST_DIR, "test_file.txt");
-    MEMORY_DIR = path.join(TEST_DIR, ".atabey/memory");
-    MEMORY_FILE = path.join(MEMORY_DIR, "PROJECT_MEMORY.md");
-});
-
-afterEach(() => {
-    fs.rmSync(TEST_DIR, { recursive: true, force: true });
-});
-
-describe("File System Tools", () => {
-    
-    describe("handleReplaceText", () => {
-        it("should replace a single occurrence of text", () => {
-            fs.writeFileSync(TEST_FILE, "hello world", "utf8");
-            const args: ToolArgs = {
-                path: TEST_FILE,
-                oldText: "world",
-                newText: "there",
-            };
-            const result = handleReplaceText(TEST_DIR, args as any);
-            expect(result.content[0].text).toContain("✅ Surgical edit successful in");
-            expect(fs.readFileSync(TEST_FILE, "utf8")).toBe("hello there\n");
-        });
-
-        it("should throw an error if text is not found", () => {
-            fs.writeFileSync(TEST_FILE, "hello world", "utf8");
-            const args: ToolArgs = {
-                path: TEST_FILE,
-                oldText: "missing",
-                newText: "found",
-            };
-            expect(() => handleReplaceText(TEST_DIR, args)).toThrowError("Text not found in file");
-        });
-
-        it("should throw an error for ambiguous replacement if allowMultiple is false", () => {
-            fs.writeFileSync(TEST_FILE, "hello world world", "utf8");
-            const args: ToolArgs = {
-                path: TEST_FILE,
-                oldText: "world",
-                newText: "there",
-                allowMultiple: false,
-            };
-            expect(() => handleReplaceText(TEST_DIR, args)).toThrowError("Ambiguous replacement");
-        });
-
-        it("should replace all occurrences of text if allowMultiple is true", () => {
-            fs.writeFileSync(TEST_FILE, "hello world world", "utf8");
-            const args: ToolArgs = {
-                path: TEST_FILE,
-                oldText: "world",
-                newText: "there",
-                allowMultiple: true,
-            };
-            const result = handleReplaceText(TEST_DIR, args as any);
-            expect(result.content[0].text).toContain("✅ Surgical edit successful in");
-            expect(fs.readFileSync(TEST_FILE, "utf8")).toBe("hello there there\n");
-        });
-
-        it("should log usage to metrics.json upon replace", () => {
-            fs.writeFileSync(TEST_FILE, "hello world", "utf8");
-            const args: ToolArgs = {
-                path: TEST_FILE,
-                oldText: "world",
-                newText: "there",
-            };
-            handleReplaceText(TEST_DIR, args);
-            const metricsPath = path.join(TEST_DIR, ".atabey/observability/metrics.json");
-            expect(fs.existsSync(metricsPath)).toBe(true);
-            const metrics = JSON.parse(fs.readFileSync(metricsPath, "utf8"));
-            expect(metrics[0].action).toContain("replace_text");
-        });
-    });
-
-    describe("handlePatchFile", () => {
-        it("should replace lines in specified range", () => {
-            fs.writeFileSync(TEST_FILE, "line1\nline2\nline3\nline4", "utf8");
-            const args: ToolArgs = {
-                path: TEST_FILE,
-                startLine: 2,
-                endLine: 3,
-                newContent: "patched2\npatched3",
-            };
-            const result = handlePatchFile(TEST_DIR, args);
-            expect(result.content[0].text).toContain("✅ File patched successfully");
-            expect(fs.readFileSync(TEST_FILE, "utf8")).toBe("line1\npatched2\npatched3\nline4");
-        });
-
-        it("should throw an error for invalid start line", () => {
-            fs.writeFileSync(TEST_FILE, "line1\nline2", "utf8");
-            const args: ToolArgs = {
-                path: TEST_FILE,
-                startLine: 5,
-                endLine: 2,
-                newContent: "error",
-            };
-            expect(() => handlePatchFile(TEST_DIR, args)).toThrowError("Invalid start line");
-        });
-
-        it("should throw an error for invalid end line", () => {
-            fs.writeFileSync(TEST_FILE, "line1\nline2", "utf8");
-            const args: ToolArgs = {
-                path: TEST_FILE,
-                startLine: 1,
-                endLine: 5,
-                newContent: "error",
-            };
-            expect(() => handlePatchFile(TEST_DIR, args)).toThrowError("Invalid end line");
-        });
-
-        it("should log usage to metrics.json upon patch", () => {
-            fs.writeFileSync(TEST_FILE, "line1\nline2\nline3\nline4", "utf8");
-            const args: ToolArgs = {
-                path: TEST_FILE,
-                startLine: 2,
-                endLine: 3,
-                newContent: "patched2\npatched3",
-            };
-            handlePatchFile(TEST_DIR, args as any);
-            const metricsPath = path.join(TEST_DIR, ".atabey/observability/metrics.json");
-            expect(fs.existsSync(metricsPath)).toBe(true);
-            const metrics = JSON.parse(fs.readFileSync(metricsPath, "utf8"));
-            expect(metrics[0].action).toContain("patch_file");
-        });
-    });
-
-    describe("handleReadFile", () => {
-        it("should read full file content", () => {
-            fs.writeFileSync(TEST_FILE, "hello world", "utf8");
-            const args: ToolArgs = { path: TEST_FILE };
-            const result = handleReadFile(TEST_DIR, args as any);
-            expect(result.content[0].text).toBe("hello world");
-        });
-
-        it("should read sliced lines", () => {
-            fs.writeFileSync(TEST_FILE, "line1\nline2\nline3\nline4", "utf8");
-            const args: ToolArgs = {
-                path: TEST_FILE,
-                startLine: 2,
-                endLine: 3
-            };
-            const result = handleReadFile(TEST_DIR, args as any);
-            expect(result.content[0].text).toBe("line2\nline3");
-        });
-
-        it("should truncate long files", () => {
-            const longContent = Array.from({ length: 1005 }, (_, i) => `line ${i + 1}`).join("\n");
-            fs.writeFileSync(TEST_FILE, longContent, "utf8");
-            const args: ToolArgs = { path: TEST_FILE };
-            const result = handleReadFile(TEST_DIR, args as any);
-            expect(result.content[0].text).toContain("TRUNCATED");
-            expect(result.content[0].text).toContain("line 1000");
-            expect(result.content[0].text).not.toContain("line 1001");
-        });
-    });
-
-    describe("handleWriteFile", () => {
-        it("should write new file and log usage", () => {
-            const args: ToolArgs = {
-                path: TEST_FILE,
-                content: "hello world"
-            };
-            const result = handleWriteFile(TEST_DIR, args);
-            expect(result.content[0].text).toContain("✅ File written:");
-            expect(fs.readFileSync(TEST_FILE, "utf8")).toBe("hello world\n");
-        });
-
-        it("should write new file and log usage to metrics.json", () => {
-            const args: ToolArgs = {
-                path: TEST_FILE,
-                content: "hello world"
-            };
-            handleWriteFile(TEST_DIR, args);
-            const metricsPath = path.join(TEST_DIR, ".atabey/observability/metrics.json");
-            expect(fs.existsSync(metricsPath)).toBe(true);
-            const metrics = JSON.parse(fs.readFileSync(metricsPath, "utf8"));
-            expect(metrics[0].action).toContain("write_file");
-            expect(metrics[0].estimatedTokens).toBeGreaterThan(0);
-        });
-
-        it("should append update to PROJECT_MEMORY.md if it exists", () => {
-            fs.mkdirSync(MEMORY_DIR, { recursive: true });
-            fs.writeFileSync(MEMORY_FILE, "## CURRENT STATUS\n", "utf8");
-            const args: ToolArgs = {
-                path: TEST_FILE,
-                content: "hello world"
-            };
-            handleWriteFile(TEST_DIR, args);
-            const memoryContent = fs.readFileSync(MEMORY_FILE, "utf8");
-            expect(memoryContent).toContain("Auto-Update");
-            expect(memoryContent).toContain("wrote file");
-        });
-    });
-});