atabey 0.0.7 → 0.0.8

package/framework-mcp/dist/src/modules/engines/planning-engine.js

@@ -0,0 +1,78 @@
+import { generateULID } from "../../cli/utils/time.js";
+import { RoutingEngine } from "./routing-engine.js";
+/**
+ * 🗺️ Planning Engine (The Strategist)
+ * Responsible for decomposing complex requests into a DAG of atomic tasks.
+ */
+export class PlanningEngine {
+    /**
+     * Creates a new Plan structure.
+     * In a real enterprise scenario, this would be fueled by an LLM prompt.
+     * For now, it provides the structural backbone.
+     */
+    static createPlan(rawTasks) {
+        const planId = generateULID();
+        const tasks = rawTasks.map((t, index) => {
+            const id = t.id || `TASK_${String(index + 1).padStart(2, "0")}`;
+            return {
+                id,
+                agent: t.agent || RoutingEngine.resolveAgent(t.task),
+                task: t.task,
+                dependencies: t.dependencies || []
+            };
+        });
+        return {
+            planId,
+            tasks
+        };
+    }
+    /**
+     * Validates a plan's integrity (no circular dependencies, all agents valid).
+     */
+    static validatePlan(plan) {
+        const errors = [];
+        const taskIds = new Set(plan.tasks.map(t => t.id));
+        for (const task of plan.tasks) {
+            // Check dependencies exist
+            for (const dep of task.dependencies) {
+                if (!taskIds.has(dep)) {
+                    errors.push(`Task ${task.id} has non-existent dependency: ${dep}`);
+                }
+            }
+            // Check circular dependencies (simple check for now)
+            if (task.dependencies.includes(task.id)) {
+                errors.push(`Task ${task.id} cannot depend on itself.`);
+            }
+        }
+        // Circular dependency detection using DFS
+        const visited = new Set();
+        const recStack = new Set();
+        const hasCycle = (taskId) => {
+            if (recStack.has(taskId))
+                return true;
+            if (visited.has(taskId))
+                return false;
+            visited.add(taskId);
+            recStack.add(taskId);
+            const task = plan.tasks.find(t => t.id === taskId);
+            if (task) {
+                for (const dep of task.dependencies) {
+                    if (hasCycle(dep))
+                        return true;
+                }
+            }
+            recStack.delete(taskId);
+            return false;
+        };
+        for (const task of plan.tasks) {
+            if (hasCycle(task.id)) {
+                errors.push("Circular dependency detected in plan.");
+                break;
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors
+        };
+    }
+}

package/framework-mcp/dist/src/modules/engines/risk-engine.js

@@ -0,0 +1,105 @@
+/**
+ * [SECURITY] Risk Engine (The Guardian)
+ * Calculates the danger level of a proposed task or operation.
+ */
+export class RiskEngine {
+    static HIGH_RISK_KEYWORDS = [
+        { word: "delete", weight: 40 },
+        { word: "drop", weight: 50 },
+        { word: "truncate", weight: 50 },
+        { word: "rm -rf", weight: 60 },
+        { word: "purge", weight: 40 },
+        { word: "format", weight: 50 },
+        { word: "force", weight: 20 },
+    ];
+    static SENSITIVE_PATHS = [
+        { pattern: /\.env/, weight: 50 },
+        { pattern: /config/, weight: 20 },
+        { pattern: /database\//, weight: 30 },
+        { pattern: /auth\//, weight: 30 },
+        { pattern: /security/, weight: 30 },
+        { pattern: /atabey/, weight: 40 }, // Framework protection
+    ];
+    /**
+     * Assesses the risk of a natural language task or command string.
+     */
+    static assessTaskRisk(task) {
+        const factors = [];
+        let totalScore = 0;
+        // 1. Keyword Analysis
+        for (const { word, weight } of this.HIGH_RISK_KEYWORDS) {
+            if (new RegExp(`\\b${word}\\b`, "i").test(task)) {
+                factors.push({
+                    factor: `Keyword: ${word}`,
+                    score: weight,
+                    description: `Detected high-risk keyword '${word}' in task description.`
+                });
+                totalScore += weight;
+            }
+        }
+        // 2. Path Sensitivity (if paths are mentioned in the task)
+        for (const { pattern, weight } of this.SENSITIVE_PATHS) {
+            if (pattern.test(task)) {
+                factors.push({
+                    factor: `Sensitive Path: ${pattern.source}`,
+                    score: weight,
+                    description: `Task involves access to sensitive path or pattern: ${pattern.source}`
+                });
+                totalScore += weight;
+            }
+        }
+        // 3. Complexity Risk (Length of task as a proxy)
+        if (task.length > 300) {
+            const score = 10;
+            factors.push({
+                factor: "High Complexity",
+                score,
+                description: "Task description is unusually long, increasing the chance of misunderstanding."
+            });
+            totalScore += score;
+        }
+        return this.finalizeAssessment(totalScore, factors);
+    }
+    /**
+     * Assesses risk based on a proposed file change.
+     */
+    static assessChangeRisk(filePath, operation) {
+        const factors = [];
+        let totalScore = 0;
+        // 1. Operation Weight
+        const opWeights = { write: 30, replace: 5, patch: 10 };
+        totalScore += opWeights[operation];
+        factors.push({
+            factor: `Operation: ${operation}`,
+            score: opWeights[operation],
+            description: `A '${operation}' operation is inherently riskier than a surgical 'replace'.`
+        });
+        // 2. File Path Risk
+        for (const { pattern, weight } of this.SENSITIVE_PATHS) {
+            if (pattern.test(filePath)) {
+                factors.push({
+                    factor: `Sensitive File: ${filePath}`,
+                    score: weight,
+                    description: "Modifying a sensitive file is high risk."
+                });
+                totalScore += weight;
+            }
+        }
+        return this.finalizeAssessment(totalScore, factors);
+    }
+    static finalizeAssessment(totalScore, factors) {
+        let severity = "LOW";
+        if (totalScore >= 80)
+            severity = "CRITICAL";
+        else if (totalScore >= 50)
+            severity = "HIGH";
+        else if (totalScore >= 20)
+            severity = "MEDIUM";
+        return {
+            totalScore: Math.min(totalScore, 100),
+            severity,
+            factors,
+            requiresApproval: totalScore >= 60
+        };
+    }
+}

package/framework-mcp/dist/src/modules/engines/routing-engine.js

@@ -0,0 +1,73 @@
+import fs from "fs";
+import path from "path";
+import { getFrameworkDir } from "../../cli/utils/memory.js";
+import { ALL_AGENTS } from "../agents/definitions.js";
+export class RoutingEngine {
+    /**
+     * Finds the best agent for a given task description based on capability scores and specialties.
+     */
+    static resolveAgent(taskDescription) {
+        const textLower = taskDescription.toLowerCase();
+        const candidates = this.getCandidates();
+        let bestAgent = "@backend"; // Default fallback
+        let bestScore = 0;
+        for (const candidate of candidates) {
+            let candidateScore = 0;
+            for (const [specialty, weight] of Object.entries(candidate.specialties)) {
+                const specLower = specialty.toLowerCase();
+                if (textLower.includes(specLower)) {
+                    candidateScore += weight;
+                }
+            }
+            if (candidateScore > bestScore) {
+                bestScore = candidateScore;
+                bestAgent = candidate.agent;
+            }
+        }
+        // Static fallback keywords if no specialty match found
+        if (bestScore === 0) {
+            if (textLower.includes("frontend") || textLower.includes("ui") || textLower.includes("page") || textLower.includes("css") || textLower.includes("html") || textLower.includes("react")) {
+                bestAgent = "@frontend";
+            }
+            else if (textLower.includes("security") || textLower.includes("audit") || textLower.includes("auth") || textLower.includes("token")) {
+                bestAgent = "@security";
+            }
+            else if (textLower.includes("database") || textLower.includes("migration") || textLower.includes("sql") || textLower.includes("schema") || textLower.includes("postgres")) {
+                bestAgent = "@database";
+            }
+            else if (textLower.includes("docker") || textLower.includes("ci") || textLower.includes("deploy") || textLower.includes("devops")) {
+                bestAgent = "@devops";
+            }
+        }
+        return bestAgent;
+    }
+    static getCandidates() {
+        const frameworkDir = getFrameworkDir();
+        const registryDir = path.join(frameworkDir, "registry");
+        let candidates = [];
+        // 1. Try Control Plane Registry first (active registered agents)
+        if (fs.existsSync(registryDir)) {
+            const registryFiles = fs.readdirSync(registryDir).filter(f => f.endsWith("_active.json"));
+            for (const file of registryFiles) {
+                try {
+                    const data = JSON.parse(fs.readFileSync(path.join(registryDir, file), "utf8"));
+                    if (data.agent && data.specialties) {
+                        candidates.push({
+                            agent: data.agent,
+                            specialties: data.specialties
+                        });
+                    }
+                }
+                catch { /* ignore */ }
+            }
+        }
+        // 2. Fallback to built-in agent definitions
+        if (candidates.length === 0) {
+            candidates = ALL_AGENTS.map(ag => ({
+                agent: ag.name.startsWith("@") ? ag.name : `@${ag.name}`,
+                specialties: ag.specialties || {}
+            }));
+        }
+        return candidates;
+    }
+}

package/framework-mcp/dist/src/modules/engines/types.js

@@ -0,0 +1 @@
+export {};

package/framework-mcp/dist/src/modules/skills/definitions.js

@@ -0,0 +1,70 @@
+/**
+ * Core Skill Definitions for Agent Atabey.
+ * Groups tools into logical capabilities for agents.
+ */
+export const CORE_SKILLS = {
+    FILE_SYSTEM: {
+        name: "File System Mastery",
+        tools: ["read_file", "write_file"],
+        description: "Enables reading and writing files in the workspace with token efficiency.",
+        mandates: [
+            "- **Token Efficiency:** When reading large files, always specify `startLine` and `endLine` to avoid loading the entire file content into context.",
+            "- **Surgical Changes:** Avoid overwriting entire files for small updates; prefer surgical edit tools."
+        ]
+    },
+    EDITING: {
+        name: "Surgical Code Modification",
+        tools: ["replace_text", "patch_file"],
+        description: "Enables surgical, precise edits to source code files without overwriting the entire content.",
+        mandates: [
+            "- **Precise Selection:** Ensure `oldText` matches the target string exactly, including all whitespace and indentation.",
+            "- **Line-based Replacement:** Use `patch_file` for multi-line block updates, specifying exact 1-indexed start and end lines."
+        ]
+    },
+    ORCHESTRATION: {
+        name: "Hermes Orchestration & Messaging",
+        tools: ["orchestrate_loop", "send_agent_message", "get_framework_status", "log_agent_action"],
+        description: "Governs inter-agent message passing, task delegation, and execution logs using the Hermes Message Broker.",
+        mandates: [
+            "- **Traceability:** Always include the active `traceId` in all messages and action logs.",
+            "- **Action Logs:** Log critical operations with `log_agent_action` to ensure transparency and accountability.",
+            "- **Message Loops:** Run `orchestrate_loop` to process queued messages and trigger state transitions."
+        ]
+    },
+    GOVERNANCE: {
+        name: "Control Plane Governance & Locking",
+        tools: ["acquire_lock", "release_lock", "register_agent", "update_contract_hash"],
+        description: "Governs access control, resource locking, type contract validation, and agent registration.",
+        mandates: [
+            "- **Locking Protocol:** Always acquire a lock via `acquire_lock` on shared resources (like memory files) before editing, and release it immediately after writing.",
+            "- **Contract Enforcement:** Run `update_contract_hash` to re-sync backend types and check for breaking API changes."
+        ]
+    },
+    QUALITY_ASSURANCE: {
+        name: "Quality Assurance & Testing",
+        tools: ["run_shell_command", "view_file"],
+        description: "Enforces testing coverage standards, code style compliance, and runs test suites.",
+        mandates: [
+            "- **Zero-Mock Policy:** Integration tests must use real test database connections or service-compatible backends; do not rely on fake mocks.",
+            "- **Coverage Standards:** Ensure new code meets the 80% test coverage threshold before transitioning to release phases."
+        ]
+    },
+    DATABASE_MANAGEMENT: {
+        name: "Database Management & Migrations",
+        tools: ["view_file", "replace_text", "run_shell_command"],
+        description: "Handles database migrations, schema design, and query optimization.",
+        mandates: [
+            "- **No Direct DB Calls in Controllers:** Database operations must be isolated inside repository or service files; controllers must never perform raw DB calls.",
+            "- **No Raw SQL Strings:** Do not write raw SQL query strings; strictly use type-safe query builders like Kysely."
+        ]
+    },
+    DEVOPS_INFRASTRUCTURE: {
+        name: "DevOps & Infrastructure",
+        tools: ["run_shell_command", "view_file"],
+        description: "Manages CI/CD pipelines, container configurations, env files, and deployments.",
+        mandates: [
+            "- **No Hardcoded Secrets:** Never embed API keys, secrets, or passwords inside configuration files or codebases.",
+            "- **Immutable Deploys:** Ensure build steps compile production bundles successfully without configuration side-effects."
+        ]
+    }
+};

package/framework-mcp/dist/src/shared/constants.js

@@ -0,0 +1,187 @@
+/**
+ * Agent Atabey — Single Source of Truth for framework constants.
+ * Import from here instead of hardcoding paths, phases, or directory names.
+ */
+// ─── Framework identity ───────────────────────────────────────────────────────
+export const FRAMEWORK = {
+    NAME: "Agent Atabey",
+    CORE_DIR: ".atabey",
+    UNIFIED_HUB_DIR: ".agents",
+    CONSTITUTION_FILE: "ATABEY.md",
+    DEFAULT_TRACE_ID: "T-000",
+    DEFAULT_PHASE: "PHASE_0",
+    DEFAULT_MANAGER_STATE: "ACTIVE",
+    DASHBOARD_PORT: 5858,
+};
+export const PROJECT_PHASES = [
+    "PHASE_0",
+    "PHASE_1",
+    "PHASE_2",
+    "PHASE_3",
+    "PHASE_4",
+];
+// ─── Adapter platform directories (native / legacy) ───────────────────────────
+export const ADAPTER_DIRS = {
+    GEMINI: ".gemini",
+    CLAUDE: ".claude",
+    GROK: ".grok",
+    CURSOR: ".cursor",
+    CODEX: ".agents",
+    ANTIGRAVITY: ".agents",
+    LOCAL: ".atabey",
+    LEGACY_AGENT: ".agent",
+};
+/** Priority order for framework directory resolution (CLI + MCP). */
+export const FRAMEWORK_DIR_CANDIDATES = [
+    FRAMEWORK.CORE_DIR,
+    ADAPTER_DIRS.CODEX,
+    ADAPTER_DIRS.CLAUDE,
+    ADAPTER_DIRS.GEMINI,
+    ADAPTER_DIRS.GROK,
+    ADAPTER_DIRS.CURSOR,
+    ADAPTER_DIRS.ANTIGRAVITY,
+    ADAPTER_DIRS.LOCAL,
+];
+/** Slug under `.agents/{slug}/` for each adapter in unified mode. */
+export const UNIFIED_ADAPTER_SLUG = {
+    gemini: "gemini",
+    claude: "claude",
+    grok: "grok",
+    cursor: "cursor",
+    codex: "codex",
+    local: "local",
+    "antigravity-cli": "antigravity",
+};
+// ─── Native agent instruction paths (legacy tool compatibility) ───────────────
+export const NATIVE_AGENT_PATHS = {
+    gemini: pathJoin(ADAPTER_DIRS.GEMINI, "agents"),
+    claude: pathJoin(ADAPTER_DIRS.CLAUDE, "agents"),
+    grok: pathJoin(ADAPTER_DIRS.GROK, "agents"),
+    cursor: pathJoin(ADAPTER_DIRS.CURSOR, "rules"),
+    codex: pathJoin(ADAPTER_DIRS.CODEX, "instructions"),
+    local: pathJoin(ADAPTER_DIRS.LOCAL, "agents"),
+    "antigravity-cli": pathJoin(ADAPTER_DIRS.ANTIGRAVITY, "agents"),
+};
+/** Legacy layout bases used by `check` and discovery (non-unified installs). */
+export const LEGACY_AGENT_LAYOUT_BASES = [
+    NATIVE_AGENT_PATHS.gemini,
+    NATIVE_AGENT_PATHS.claude,
+    NATIVE_AGENT_PATHS.cursor,
+    NATIVE_AGENT_PATHS.grok,
+    NATIVE_AGENT_PATHS.codex,
+    NATIVE_AGENT_PATHS.local,
+    NATIVE_AGENT_PATHS["antigravity-cli"],
+];
+// ─── Framework internal subdirectories (under `.atabey/`) ──────────────────
+export const FRAMEWORK_SUBDIRS = {
+    AGENTS: "agents",
+    SKILLS: "skills",
+    KNOWLEDGE: "knowledge",
+    PROMPTS: "prompts",
+    MEMORY: "memory",
+    ROUTER: "router",
+    REGISTRY: "registry",
+    OBSERVABILITY: "observability",
+    RULES: "rules",
+    MESSAGES: "messages",
+    LOGS: "logs",
+    MEMORY_GRAPH: "memory-graph",
+    DASHBOARD: "dashboard",
+    UI_DIST: "ui",
+};
+export const CORE_SCAFFOLD_SUBDIRS = [
+    FRAMEWORK_SUBDIRS.KNOWLEDGE,
+    FRAMEWORK_SUBDIRS.PROMPTS,
+    FRAMEWORK_SUBDIRS.MEMORY,
+    FRAMEWORK_SUBDIRS.ROUTER,
+    FRAMEWORK_SUBDIRS.REGISTRY,
+    FRAMEWORK_SUBDIRS.OBSERVABILITY,
+    FRAMEWORK_SUBDIRS.RULES,
+];
+export const RUNTIME_SUBDIRS = [
+    FRAMEWORK_SUBDIRS.MESSAGES,
+    FRAMEWORK_SUBDIRS.LOGS,
+    FRAMEWORK_SUBDIRS.MEMORY_GRAPH,
+];
+export const MEMORY_SUBDIRS = {
+    TASKS: "tasks",
+    HISTORY: "history",
+};
+export const MEMORY_FILES = {
+    STATE: "state.json",
+    STATUS: "status.json",
+    PROJECT_MEMORY: "PROJECT_MEMORY.md",
+    SHARED_FACTS: "shared-facts.json",
+};
+// ─── Monorepo default paths ───────────────────────────────────────────────────
+export const DEFAULT_MONOREPO_PATHS = {
+    backend: "apps/backend",
+    frontend: "apps/web",
+    mobile: "apps/mobile",
+    docs: "docs",
+    tests: "tests",
+};
+/** Cursor rule globs per agent role (enterprise monorepo layout). */
+export const CURSOR_AGENT_GLOBS = {
+    manager: "**/*",
+    security: "**/*",
+    architect: "**/*",
+    backend: `${DEFAULT_MONOREPO_PATHS.backend}/**/*`,
+    frontend: `${DEFAULT_MONOREPO_PATHS.frontend}/**/*`,
+    mobile: `${DEFAULT_MONOREPO_PATHS.mobile}/**/*`,
+    native: "apps/native/**/*",
+    database: `${DEFAULT_MONOREPO_PATHS.backend}/src/database/**/*`,
+    devops: "{.github,docker,infra,scripts,*.yml,*.yaml,Dockerfile*}",
+    quality: "**/*",
+    analyst: "{docs,specs,contracts}/**/*",
+    explorer: "**/*",
+    git: "**/*",
+};
+// ─── MCP & environment ──────────────────────────────────────────────────────
+export const MCP = {
+    SERVER_NAME: "atabey",
+    ROOT_CONFIG_FILE: "mcp.json",
+    PROJECT_ROOT_ENV: "ATABEY_PROJECT_ROOT",
+    TEST_DIR_ENV: "ATABEY_TEST_DIR",
+    SERVER_DIST_PATH: "framework-mcp/dist/index.js",
+};
+export const ROOT_CONFIG_FILES = {
+    MCP: MCP.ROOT_CONFIG_FILE,
+    DOT_MCP: ".mcp.json",
+    ENV_EXAMPLE: ".env.example",
+    VSCODE_MCP: ".vscode/mcp.json",
+};
+// ─── Shim template placeholders ───────────────────────────────────────────────
+export const TEMPLATE_PLACEHOLDERS = {
+    FRAMEWORK_DIR: "{{FRAMEWORK_DIR}}",
+    ADAPTER: "{{ADAPTER}}",
+    BACKEND_DIR: "{{BACKEND_DIR}}",
+    FRONTEND_DIR: "{{FRONTEND_DIR}}",
+    DOCS_DIR: "{{DOCS_DIR}}",
+    TESTS_DIR: "{{TESTS_DIR}}",
+};
+// ─── File extensions ─────────────────────────────────────────────────────────
+export const AGENT_FILE_EXT = {
+    MARKDOWN: ".md",
+    CURSOR_RULE: ".mdc",
+};
+// ─── Path helpers ─────────────────────────────────────────────────────────────
+export function pathJoin(...segments) {
+    return segments.filter(Boolean).join("/");
+}
+export function corePath(...segments) {
+    return pathJoin(FRAMEWORK.CORE_DIR, ...segments);
+}
+export function unifiedHubPath(...segments) {
+    return pathJoin(FRAMEWORK.UNIFIED_HUB_DIR, ...segments);
+}
+export function unifiedAdapterPath(slug, ...segments) {
+    return unifiedHubPath(slug, ...segments);
+}
+export function knowledgePath(filename) {
+    return corePath(FRAMEWORK_SUBDIRS.KNOWLEDGE, filename);
+}
+/** Backward-compatible aliases */
+export const CORE_FRAMEWORK_DIR = FRAMEWORK.CORE_DIR;
+export const UNIFIED_HUB_DIR = FRAMEWORK.UNIFIED_HUB_DIR;
+export const SKILLS_HUB_PATH = pathJoin(UNIFIED_HUB_DIR, FRAMEWORK_SUBDIRS.SKILLS);

package/framework-mcp/dist/src/shared/errors.js

@@ -0,0 +1,68 @@
+/**
+ * Enterprise Base Error class for the Agent Atabey Framework.
+ */
+export class AtabeyBaseError extends Error {
+    code;
+    timestamp;
+    details;
+    solution;
+    constructor(message, code = "ATABEY_INTERNAL_ERROR", details, solution) {
+        super(message);
+        this.name = this.constructor.name;
+        this.code = code;
+        this.timestamp = new Date();
+        this.details = details;
+        this.solution = solution;
+        // Ensure proper prototype chain and capture stack trace
+        Object.setPrototypeOf(this, new.target.prototype);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+    /**
+     * Converts the error into a structured JSON log format.
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            code: this.code,
+            timestamp: this.timestamp.toISOString(),
+            details: this.details,
+            solution: this.solution,
+            stack: this.stack,
+        };
+    }
+}
+/**
+ * Thrown when configuration loading or validation fails.
+ */
+export class ConfigurationError extends AtabeyBaseError {
+    constructor(message, details, solution) {
+        super(message, "CONFIGURATION_ERROR", details, solution);
+    }
+}
+/**
+ * Thrown when data schema or payload validation fails.
+ */
+export class ValidationError extends AtabeyBaseError {
+    constructor(message, details, solution) {
+        super(message, "VALIDATION_ERROR", details, solution);
+    }
+}
+/**
+ * Thrown when adapter initialization or execution fails.
+ */
+export class AdapterError extends AtabeyBaseError {
+    constructor(message, adapterId, details, solution) {
+        super(`Adapter '${adapterId}' failure: ${message}`, "ADAPTER_ERROR", details, solution);
+    }
+}
+/**
+ * Thrown when orchestration or agent communication fails.
+ */
+export class OrchestrationError extends AtabeyBaseError {
+    constructor(message, details, solution) {
+        super(message, "ORCHESTRATION_ERROR", details, solution);
+    }
+}

package/framework-mcp/dist/src/shared/fs.js

@@ -0,0 +1,51 @@
+import fs from "fs";
+import path from "path";
+import { execFileSync } from "child_process";
+import { logger } from "./logger.js";
+export function ensureDir(dirPath, dryRun = false) {
+    if (!fs.existsSync(dirPath)) {
+        if (dryRun) {
+            logger.info(`[DRY RUN] Would create directory: ${dirPath}`);
+        }
+        else {
+            fs.mkdirSync(dirPath, { recursive: true });
+        }
+    }
+}
+/**
+ * Writes content to a file atomically by using a temporary file.
+ * This prevents data corruption during unexpected system failures.
+ */
+export function writeTextFile(filePath, content, dryRun = false) {
+    if (dryRun) {
+        logger.info(`[DRY RUN] Would write file: ${filePath}`);
+        return;
+    }
+    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))
+            fs.unlinkSync(tempPath);
+        throw err;
+    }
+}
+export function appendFile(filePath, content, dryRun = false) {
+    if (dryRun) {
+        logger.info(`[DRY RUN] Would append to file: ${filePath}`);
+        return;
+    }
+    ensureDir(path.dirname(filePath));
+    fs.appendFileSync(filePath, content, "utf8");
+}
+export function writeJsonFile(filePath, value, dryRun = false) {
+    writeTextFile(filePath, JSON.stringify(value, null, 2), dryRun);
+}
+export function runCommandQuiet(command, args, cwd) {
+    execFileSync(command, args, { cwd, stdio: "ignore" });
+}