atabey 0.0.11 → 0.0.13

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

@@ -0,0 +1,100 @@
+import chalk from "chalk";
+import readline from "readline";
+/**
+ * Professional UI Utilities for Agent Atabey CLI.
+ * Standardizes headers, status boxes, and strategic intent reporting.
+ */
+export const UI = {
+    /**
+     * Renders a strategic intent block similar to Gemini CLI's topic updates.
+     */
+    intent: (title, intent) => {
+        process.stdout.write(`\n${chalk.bold.cyan(title)}:\n`);
+        process.stdout.write(`${chalk.italic.gray(`  ${intent}`)}\n\n`);
+    },
+    /**
+     * Renders a professional agent execution box.
+     */
+    agentBox: (agentName, action, details) => {
+        const width = process.stdout.columns || 80;
+        const line = "─".repeat(Math.max(0, width - 2));
+        process.stdout.write(chalk.gray(`╭${line}╮`) + "\n");
+        const padding = Math.max(0, width - agentName.length - 27);
+        process.stdout.write(`${chalk.gray("│")} ${chalk.bold.yellow("=")} ${chalk.white(`Running Agent: ${chalk.bold.green(agentName)}...`)} ${chalk.gray("(ctrl+o to expand)".padStart(padding))} ${chalk.gray("│")}\n`);
+        if (action) {
+            const paddingAction = Math.max(0, width - action.length - 6);
+            process.stdout.write(`${chalk.gray("│")} ${chalk.blue("!")} ${chalk.cyan(action)} ${" ".repeat(paddingAction)} ${chalk.gray("│")}\n`);
+        }
+        if (details) {
+            const paddingDetails = Math.max(0, width - details.length - 7);
+            process.stdout.write(`${chalk.gray("│")}   ${chalk.gray(details.slice(0, width - 10))} ${" ".repeat(paddingDetails)} ${chalk.gray("│")}\n`);
+        }
+        process.stdout.write(chalk.gray(`╰${line}╯`) + "\n");
+    },
+    /**
+     * Renders the live Terminal UI dashboard for Hermes.
+     */
+    renderDashboard: (state) => {
+        // Clear screen and move cursor to top-left
+        readline.cursorTo(process.stdout, 0, 0);
+        readline.clearScreenDown(process.stdout);
+        const width = process.stdout.columns || 80;
+        const line = chalk.gray("─".repeat(width));
+        // Header
+        process.stdout.write(chalk.bgBlue.white.bold(" [ATABEY] Hermes Terminal Dashboard ".padEnd(width)) + "\n");
+        process.stdout.write(` ${chalk.cyan("Active Trace:")} ${chalk.bold(state.traceId)}   ${chalk.cyan("Phase:")} ${state.phase}   ${chalk.cyan("Pending Tasks:")} ${state.pendingCount}\n`);
+        process.stdout.write(line + "\n");
+        // Agents Table
+        process.stdout.write(chalk.bold.yellow(" [AGENT STATUS]\n"));
+        process.stdout.write(chalk.gray(String(" Agent").padEnd(15)) + chalk.gray(String("State").padEnd(12)) + chalk.gray("Current Task\n"));
+        for (const a of state.agents) {
+            const nameColor = a.name === "manager" ? chalk.blueBright : a.name === "quality" ? chalk.magenta : chalk.green;
+            const stateColor = a.state === "EXECUTING" ? chalk.bgYellow.black : a.state === "READY" ? chalk.gray : chalk.white;
+            const cleanName = `@${a.name}`.padEnd(14);
+            const cleanState = `[${a.state}]`.padEnd(11);
+            const cleanTask = a.task.length > (width - 28) ? a.task.substring(0, width - 31) + "..." : a.task;
+            process.stdout.write(` ${nameColor(cleanName)} ${stateColor(cleanState)} ${chalk.white(cleanTask)}\n`);
+        }
+        process.stdout.write(line + "\n");
+        // Recent Logs
+        process.stdout.write(chalk.bold.yellow(" [RECENT ACTIVITY]\n"));
+        for (const log of state.logs.slice(0, 8)) {
+            const time = new Date(log.timestamp).toLocaleTimeString();
+            const logLine = ` [${chalk.gray(time)}] ${chalk.cyan(log.agent)}: ${log.action} - ${log.summary}`;
+            const cleanLog = logLine.length > width ? logLine.substring(0, width - 3) + "..." : logLine;
+            process.stdout.write(`${cleanLog}\n`);
+        }
+        process.stdout.write("\n" + chalk.italic.gray(" Press Ctrl+C to exit. Waiting for new messages...") + "\n");
+    },
+    /**
+     * Renders a success status message.
+     */
+    success: (msg) => {
+        process.stdout.write(`${chalk.bold.green("[OK]")} ${msg}\n`);
+    },
+    /**
+     * Renders an error status message.
+     */
+    error: (msg) => {
+        process.stderr.write(`${chalk.bold.red("[ERROR]")} ${chalk.red(msg)}\n`);
+    },
+    /**
+     * Renders a warning status message.
+     */
+    warning: (msg) => {
+        process.stdout.write(`${chalk.bold.yellow("[WARN]")} ${chalk.yellow(msg)}\n`);
+    },
+    /**
+     * Renders an info/log message (non-critical, informational).
+     */
+    info: (msg) => {
+        process.stdout.write(`${chalk.cyan("[INFO]")} ${msg}\n`);
+    },
+    /**
+     * Renders an info/divider line.
+     */
+    divider: () => {
+        const width = process.stdout.columns || 80;
+        process.stdout.write(chalk.gray("─".repeat(width)) + "\n");
+    }
+};

package/framework-mcp/dist/src/modules/memory/core.js

@@ -0,0 +1,99 @@
+import crypto from "crypto";
+import { generateEmbedding } from "./embedding.js";
+import { VectorStore } from "./vector-store.js";
+/**
+ * [MEMORY] Core Memory Service
+ * High-level API for managing project knowledge and embeddings.
+ * Uses OpenAI Embedding API when available, falls back to TF-IDF.
+ */
+export class CoreMemory {
+    static VECTOR_DIM = 384;
+    static STOP_WORDS = new Set([
+        "the", "a", "an", "and", "or", "but", "in", "on", "at", "to", "for",
+        "of", "with", "by", "from", "as", "is", "was", "are", "were", "be",
+        "been", "being", "have", "has", "had", "do", "does", "did", "will",
+        "would", "could", "should", "may", "might", "shall", "can", "need",
+    ]);
+    static async init() {
+        VectorStore.initialize();
+    }
+    /**
+     * Records a new piece of knowledge into the core memory.
+     * Uses OpenAI Embedding API when available, falls back to TF-IDF.
+     */
+    static async remember(params) {
+        const id = crypto.createHash("sha256").update(params.content + (params.filePath || "")).digest("hex");
+        // Use provided vector or generate via embedding service
+        const vector = params.vector || await generateEmbedding(params.content);
+        const entry = {
+            id,
+            content: params.content,
+            vector,
+            metadata: {
+                category: params.category,
+                traceId: params.traceId,
+                filePath: params.filePath,
+                tags: params.tags || [],
+                createdAt: new Date().toISOString()
+            }
+        };
+        await VectorStore.addEntry(entry);
+        return id;
+    }
+    /**
+     * Searches the memory for relevant knowledge using cosine similarity.
+     * Uses OpenAI Embedding API when available for the query vector.
+     */
+    static async recall(query, options) {
+        const vector = options.queryVector || await generateEmbedding(query);
+        return VectorStore.search(vector, options.limit || 5, options.category);
+    }
+    /**
+     * Generates a TF-IDF style embedding vector from text.
+     * Kept for backward compatibility and as fallback.
+     */
+    static generateEmbedding(text) {
+        const vector = new Array(this.VECTOR_DIM).fill(0);
+        // Tokenize and clean
+        const tokens = text
+            .toLowerCase()
+            .replace(/[^a-z0-9çşıöğü_ ]/g, " ")
+            .split(/\s+/)
+            .filter(t => t.length > 2 && !this.STOP_WORDS.has(t));
+        if (tokens.length === 0) {
+            return vector;
+        }
+        // Calculate term frequency
+        const tf = new Map();
+        for (const token of tokens) {
+            tf.set(token, (tf.get(token) || 0) + 1);
+        }
+        // Map each unique token to vector positions using hash
+        for (const [token, freq] of tf) {
+            for (let i = 0; i < token.length - 1; i++) {
+                const ngram = token.substring(i, i + 2);
+                const pos = this.hashToPosition(ngram);
+                vector[pos] += freq * (i + 1) / token.length;
+            }
+        }
+        // Normalize to unit vector
+        const magnitude = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
+        if (magnitude > 0) {
+            for (let i = 0; i < this.VECTOR_DIM; i++) {
+                vector[i] /= magnitude;
+            }
+        }
+        return vector;
+    }
+    /**
+     * Deterministically maps a string to a position in the vector.
+     */
+    static hashToPosition(value) {
+        let hash = 0;
+        for (let i = 0; i < value.length; i++) {
+            hash = ((hash << 5) - hash) + value.charCodeAt(i);
+            hash |= 0;
+        }
+        return Math.abs(hash) % this.VECTOR_DIM;
+    }
+}

package/framework-mcp/dist/src/modules/memory/embedding.js

@@ -0,0 +1,130 @@
+/**
+ * [MEMORY] Embedding Service
+ *
+ * Real embedding generation with OpenAI API integration.
+ * Falls back to TF-IDF if no API key is available.
+ *
+ * Supported methods:
+ * 1. OpenAI Embedding API (text-embedding-3-small) — 1536 dimensions
+ * 2. TF-IDF fallback (local method) — 384 dimensions
+ */
+import fs from "fs";
+import path from "path";
+import { logger } from "../../shared/logger.js";
+import { CoreMemory } from "./core.js";
+const EMBEDDING_API = "https://api.openai.com/v1/embeddings";
+const EMBEDDING_MODEL = "text-embedding-3-small";
+const EMBEDDING_DIM = 1536;
+/**
+ * Reads the API key from environment variable or .env file.
+ */
+function getApiKey() {
+    if (process.env.OPENAI_API_KEY)
+        return process.env.OPENAI_API_KEY;
+    try {
+        const envPath = path.join(process.cwd(), ".env");
+        if (fs.existsSync(envPath)) {
+            const content = fs.readFileSync(envPath, "utf8");
+            const match = content.match(/^OPENAI_API_KEY=(.+)$/m);
+            if (match)
+                return match[1].trim();
+        }
+    }
+    catch {
+        // Silently ignore .env read errors
+    }
+    return null;
+}
+/**
+ * Generates an embedding vector for the given text.
+ *
+ * Priority:
+ * 1. OpenAI API (if API key is available)
+ * 2. TF-IDF fallback (local)
+ */
+export async function generateEmbedding(text) {
+    const apiKey = getApiKey();
+    // Use OpenAI API if available
+    if (apiKey) {
+        try {
+            const response = await fetch(EMBEDDING_API, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Authorization": `Bearer ${apiKey}`,
+                },
+                body: JSON.stringify({
+                    input: text,
+                    model: EMBEDDING_MODEL,
+                }),
+            });
+            if (!response.ok) {
+                logger.warn(`OpenAI API error: ${response.status}. Falling back to TF-IDF.`);
+                return fallbackEmbedding(text);
+            }
+            const data = await response.json();
+            if (data?.data?.[0]?.embedding) {
+                return data.data[0].embedding;
+            }
+        }
+        catch (err) {
+            logger.warn(`OpenAI API call failed: ${err.message}. Falling back to TF-IDF.`);
+        }
+    }
+    // Fallback: TF-IDF
+    return fallbackEmbedding(text);
+}
+/**
+ * TF-IDF fallback embedding using CoreMemory.generateEmbedding.
+ * OpenAI embedding is 1536 dimensions, TF-IDF is 384 dimensions.
+ * Pads TF-IDF output to 1536 for compatibility.
+ */
+function fallbackEmbedding(text) {
+    const tfidfVector = CoreMemory.generateEmbedding(text); // 384 dimensions
+    // Pad 384 → 1536
+    const padded = new Array(EMBEDDING_DIM).fill(0);
+    for (let i = 0; i < tfidfVector.length; i++) {
+        padded[i] = tfidfVector[i];
+    }
+    return padded;
+}
+/**
+ * Batch embedding generation. Single API call for multiple texts.
+ * OpenAI supports batch requests natively.
+ */
+export async function generateEmbeddings(texts) {
+    const apiKey = getApiKey();
+    if (apiKey) {
+        try {
+            const response = await fetch(EMBEDDING_API, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Authorization": `Bearer ${apiKey}`,
+                },
+                body: JSON.stringify({
+                    input: texts,
+                    model: EMBEDDING_MODEL,
+                }),
+            });
+            if (response.ok) {
+                const data = await response.json();
+                if (data?.data) {
+                    return data.data.map(d => d.embedding);
+                }
+            }
+        }
+        catch {
+            // fallback
+        }
+    }
+    // Fallback for each text
+    return Promise.all(texts.map(t => fallbackEmbedding(t)));
+}
+/**
+ * Checks if a vector is an OpenAI embedding (1536 dimensions)
+ * as opposed to TF-IDF (384 dimensions).
+ */
+export function isOpenAIEmbedding(vector) {
+    return vector.length === EMBEDDING_DIM;
+}

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

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

package/framework-mcp/dist/src/modules/memory/vector-store.js

@@ -0,0 +1,74 @@
+import { Storage } from "../../shared/storage.js";
+/**
+ * [MEMORY] Vector Store Implementation
+ * Uses SQLite for persistence and JS-based cosine similarity for retrieval.
+ * Zero-Docker, Lightweight, and Local.
+ */
+export class VectorStore {
+    static TABLE_NAME = "vector_memory";
+    static initialize() {
+        const db = Storage.getDB();
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS ${this.TABLE_NAME} (
+                id TEXT PRIMARY KEY,
+                content TEXT,
+                vector BLOB,
+                category TEXT,
+                metadata TEXT,
+                created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+            )
+        `);
+    }
+    static async addEntry(entry) {
+        const db = Storage.getDB();
+        const vectorBuffer = entry.vector ? Buffer.from(new Float32Array(entry.vector).buffer) : null;
+        db.prepare(`
+            INSERT INTO ${this.TABLE_NAME} (id, content, vector, category, metadata)
+            VALUES (?, ?, ?, ?, ?)
+            ON CONFLICT(id) DO UPDATE SET
+                content = excluded.content,
+                vector = excluded.vector,
+                metadata = excluded.metadata
+        `).run(entry.id, entry.content, vectorBuffer, entry.metadata.category, JSON.stringify(entry.metadata));
+    }
+    static async search(queryVector, limit = 5, category) {
+        const db = Storage.getDB();
+        let query = `SELECT * FROM ${this.TABLE_NAME}`;
+        const params = [];
+        if (category) {
+            query += " WHERE category = ?";
+            params.push(category);
+        }
+        const rows = db.prepare(query).all(...params);
+        const results = [];
+        for (const row of rows) {
+            if (!row.vector)
+                continue;
+            const entryVector = Array.from(new Float32Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength / 4));
+            const score = this.cosineSimilarity(queryVector, entryVector);
+            results.push({
+                entry: {
+                    id: row.id,
+                    content: row.content,
+                    vector: entryVector,
+                    metadata: JSON.parse(row.metadata)
+                },
+                score
+            });
+        }
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    static cosineSimilarity(vecA, vecB) {
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < vecA.length; i++) {
+            dotProduct += vecA[i] * vecB[i];
+            normA += vecA[i] * vecA[i];
+            normB += vecB[i] * vecB[i];
+        }
+        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+    }
+}

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: parseInt(process.env.PORT || process.env.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 [FRAMEWORK.CORE_DIR, ...segments.filter(Boolean)].join("/");
+}
+export function unifiedHubPath(...segments) {
+    return [FRAMEWORK.UNIFIED_HUB_DIR, ...segments.filter(Boolean)].join("/");
+}
+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/fs.js

@@ -0,0 +1,53 @@
+import { execFileSync } from "child_process";
+import fs from "fs";
+import path from "path";
+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));
+    // Atomic append: oku → ekle → atomic yaz
+    const existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : "";
+    writeTextFile(filePath, existing + content);
+}
+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" });
+}