cf-claw 3.0.0

package/dist/tools/index.js

@@ -0,0 +1,1109 @@
+import { addFact, searchFacts, searchConversations, deleteFact, getAllFacts, } from "../memory.js";
+import { textToSpeech } from "../tts.js";
+import { addEntity, addRelation, getEntity, getEntityRelations, searchEntities, traverseGraph, } from "../memory/knowledge-graph.js";
+import { createTask, listTasks, pauseTask, resumeTask, deleteScheduledTask, } from "../scheduler/index.js";
+import { createWebhook, listWebhooks, deleteWebhook, } from "../webhooks/index.js";
+import { sessionsCreate, sessionsList, sessionsHistory, sessionsSend, sessionsDelete, } from "../sessions.js";
+import { canvasManager } from "../canvas.js";
+import { docSave, docList, docRead, docDelete, docSearch, } from "../documents.js";
+import { createAgent, listAgents, getAgent, deleteAgent, } from "../agents.js";
+import { createSkill, patchSkill, editSkill, deleteSkill, viewSkill, } from "./skills-manage.js";
+import { reloadSkills, listLoadedSkills } from "../skills/index.js";
+import shellExec from "./shell.js";
+import { fileTools } from "./files.js";
+import configTools from "./config-tools.js";
+import browser from "./browser.js";
+import webSearch from "./web-search.js";
+import { getMCPTools } from "./mcp-bridge.js";
+import { sendToTelegram } from "../bot.js";
+import { config } from "../config.js";
+import { factoryCreate, listFactoryProjects, getFactoryProject, getFactoryTasks, setProjectStatus, forceRetryTask, restartFactoryProject, getAgentPipelineRoles, } from "../factory.js";
+const getCurrentTime = {
+    name: "get_current_time",
+    description: "Returns the current date and time. Use this when the user asks what time it is or needs the current date.",
+    input_schema: {
+        type: "object",
+        properties: {},
+        required: [],
+    },
+    execute: async () => {
+        const now = new Date();
+        return now.toLocaleString("sv-SE", {
+            dateStyle: "full",
+            timeStyle: "medium",
+            timeZone: "Europe/Stockholm",
+        });
+    },
+};
+const remember = {
+    name: "remember",
+    description: "Manually save a specific fact to long-term memory. Most facts are auto-extracted, but use this for things the auto-extraction might miss or when the user explicitly asks you to remember something.",
+    input_schema: {
+        type: "object",
+        properties: {
+            content: {
+                type: "string",
+                description: "The information to remember. Be specific and self-contained.",
+            },
+            category: {
+                type: "string",
+                description: 'Category: "preference", "personal", "decision", "project", "technical", "relationship", or "general"',
+            },
+        },
+        required: ["content"],
+    },
+    execute: async (input) => {
+        const content = input.content;
+        const category = input.category || "general";
+        const result = await addFact(content, category);
+        return result.updated
+            ? `🔄 Updated existing fact #${result.id}: "${content}"`
+            : `✅ Fact saved (id: ${result.id}): "${content}"`;
+    },
+};
+const recall = {
+    name: "recall",
+    description: "Search long-term memory for relevant facts using hybrid keyword + semantic search. Use this when you need to find specific information about the user or past decisions.",
+    input_schema: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "Search query — keywords or a natural phrase.",
+            },
+        },
+        required: ["query"],
+    },
+    execute: async (input) => {
+        const query = input.query;
+        const facts = query.trim()
+            ? await searchFacts(query)
+            : getAllFacts();
+        if (facts.length === 0) {
+            return "No facts found matching that query.";
+        }
+        const formatted = facts
+            .map((f) => `[id:${f.id}] [${f.category}] ${f.content}`)
+            .join("\n");
+        return `Found ${facts.length} fact${facts.length === 1 ? "" : "s"}:\n${formatted}`;
+    },
+};
+const forget = {
+    name: "forget",
+    description: "Delete a specific fact by its ID. Use this when information is outdated, incorrect, or the user asks you to forget something. Use recall first to find the fact ID.",
+    input_schema: {
+        type: "object",
+        properties: {
+            id: {
+                type: "number",
+                description: "The ID of the fact to delete.",
+            },
+        },
+        required: ["id"],
+    },
+    execute: async (input) => {
+        const id = input.id;
+        const deleted = deleteFact(id);
+        return deleted
+            ? `✅ Fact ${id} has been deleted.`
+            : `⚠️ No fact found with id ${id}.`;
+    },
+};
+const searchConversationsTool = {
+    name: "search_conversations",
+    description: "Deep search through the full conversation history using hybrid keyword + semantic search. Use this to find specific past discussions, things the user said, or context from older conversations.",
+    input_schema: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "Search query — what to look for in past conversations.",
+            },
+        },
+        required: ["query"],
+    },
+    execute: async (input) => {
+        const query = input.query;
+        const results = await searchConversations(query, 10);
+        if (results.length === 0) {
+            return "No matching conversations found.";
+        }
+        const formatted = results
+            .map((r) => `[${r.role}] ${r.content}`)
+            .join("\n---\n");
+        return `Found ${results.length} relevant message${results.length === 1 ? "" : "s"}:\n${formatted}`;
+    },
+};
+const speak = {
+    name: "speak",
+    description: "Send a voice message back to the user using text-to-speech. Use this when the user asks you to speak, reply with voice, send an audio message, or when replying to a voice message and a spoken reply feels natural.",
+    input_schema: {
+        type: "object",
+        properties: {
+            text: {
+                type: "string",
+                description: "The text to speak aloud. Write it as natural speech — no markdown, no bullet points.",
+            },
+        },
+        required: ["text"],
+    },
+    execute: async (input) => {
+        const text = input.text;
+        console.log(`🔊 Speaking: ${text.substring(0, 60)}${text.length > 60 ? "…" : ""}`);
+        const audioPath = await textToSpeech(text);
+        return `[VOICE:${audioPath}]`;
+    },
+};
+const knowledgeAdd = {
+    name: "knowledge_add",
+    description: "Add entities and relationships to the knowledge graph. Use to track people, projects, concepts and how they relate.",
+    input_schema: {
+        type: "object",
+        properties: {
+            entity_name: { type: "string", description: "Name of the entity." },
+            entity_type: { type: "string", description: 'Type (e.g. "person", "project", "concept"). Default: "thing".' },
+            relation_to: { type: "string", description: "Name of a related entity." },
+            relation_type: { type: "string", description: 'Type of relation (e.g. "works_on", "knows", "part_of").' },
+        },
+        required: ["entity_name"],
+    },
+    execute: async (input) => {
+        const name = input.entity_name;
+        const type = input.entity_type || "thing";
+        const results = [];
+        const entity = await addEntity(name, type);
+        results.push(`✅ Entity "${name}" (${type}) — id: ${entity.id}`);
+        if (input.relation_to && input.relation_type) {
+            const relResult = await addRelation(name, input.relation_to, input.relation_type);
+            if (relResult) {
+                results.push(`✅ Relation: ${name} —[${input.relation_type}]→ ${input.relation_to}`);
+            }
+            else {
+                results.push(`⚠️ Could not create relation — "${input.relation_to}" not found. Add it first.`);
+            }
+        }
+        return results.join("\n");
+    },
+};
+const knowledgeQuery = {
+    name: "knowledge_query",
+    description: "Search and traverse the knowledge graph. Find entities, their relationships, and connections.",
+    input_schema: {
+        type: "object",
+        properties: {
+            query: { type: "string", description: "Entity name or search term." },
+            action: {
+                type: "string",
+                description: '"get" (lookup by name), "search" (fuzzy search), "relations" (get relations), "traverse" (graph traversal). Default: "get"',
+            },
+            depth: { type: "number", description: "Max traversal depth (for traverse action). Default: 3." },
+        },
+        required: ["query"],
+    },
+    execute: async (input) => {
+        const query = input.query;
+        const action = input.action || "get";
+        switch (action) {
+            case "search": {
+                const entities = searchEntities(query, 10);
+                if (entities.length === 0)
+                    return "No entities found.";
+                return entities.map((e) => `- ${e.name} (${e.type})`).join("\n");
+            }
+            case "relations": {
+                const relations = getEntityRelations(query);
+                if (relations.outgoing.length === 0 && relations.incoming.length === 0) {
+                    return `No relations found for "${query}".`;
+                }
+                const lines = [];
+                for (const r of relations.outgoing) {
+                    lines.push(`${query} —[${r.relation_type}]→ ${r.target_name}`);
+                }
+                for (const r of relations.incoming) {
+                    lines.push(`${r.source_name} —[${r.relation_type}]→ ${query}`);
+                }
+                return lines.join("\n");
+            }
+            case "traverse": {
+                const depth = input.depth || 3;
+                const graph = traverseGraph(query, depth);
+                if (graph.entities.length === 0)
+                    return `Entity "${query}" not found.`;
+                const entityLines = graph.entities.map((e) => `- ${e.name} (${e.type})`);
+                const relLines = graph.relations.map((r) => `  ${r.from} —[${r.type}]→ ${r.to}`);
+                return `Entities:\n${entityLines.join("\n")}\nRelations:\n${relLines.join("\n")}`;
+            }
+            default: {
+                const entity = getEntity(query);
+                if (!entity)
+                    return `Entity "${query}" not found. Use action "search" to look for similar entities.`;
+                return `Name: ${entity.name}\nType: ${entity.type}\nProperties: ${JSON.stringify(entity.properties)}`;
+            }
+        }
+    },
+};
+const scheduleTask = {
+    name: "schedule_task",
+    description: "Create a scheduled task. Supports cron expressions (e.g. '30 9 * * *' for 9:30 daily) or natural intervals (e.g. 'every 30 min').",
+    input_schema: {
+        type: "object",
+        properties: {
+            name: { type: "string", description: "Name for this task." },
+            cron: { type: "string", description: "Cron expression or interval (e.g. '30 9 * * *' or 'every 60 min')." },
+            prompt: { type: "string", description: "Prompt to execute when the task fires." },
+        },
+        required: ["name", "cron", "prompt"],
+    },
+    execute: async (input) => {
+        const task = createTask(input.name, input.cron, input.prompt);
+        return `✅ Scheduled task "${task.name}" (id: ${task.id})\nCron: ${task.cron_expr}\nNext run: ${task.next_run}`;
+    },
+};
+const scheduleList = {
+    name: "schedule_list",
+    description: "List all scheduled tasks.",
+    input_schema: {
+        type: "object",
+        properties: {},
+        required: [],
+    },
+    execute: async () => {
+        const tasks = listTasks();
+        if (tasks.length === 0)
+            return "No scheduled tasks.";
+        return tasks.map((t) => `[${t.enabled ? "✅" : "⏸"}] #${t.id} "${t.name}" — ${t.cron_expr} (last: ${t.last_run || "never"})`).join("\n");
+    },
+};
+const scheduleToggle = {
+    name: "schedule_toggle",
+    description: "Pause or resume a scheduled task.",
+    input_schema: {
+        type: "object",
+        properties: {
+            id: { type: "number", description: "Task ID." },
+            action: { type: "string", description: '"pause" or "resume".' },
+        },
+        required: ["id", "action"],
+    },
+    execute: async (input) => {
+        const id = input.id;
+        const action = input.action;
+        if (action === "pause") {
+            pauseTask(id);
+            return `⏸ Task ${id} paused.`;
+        }
+        else {
+            resumeTask(id);
+            return `▶️ Task ${id} resumed.`;
+        }
+    },
+};
+const scheduleDelete = {
+    name: "schedule_delete",
+    description: "Delete a scheduled task.",
+    input_schema: {
+        type: "object",
+        properties: {
+            id: { type: "number", description: "Task ID to delete." },
+        },
+        required: ["id"],
+    },
+    execute: async (input) => {
+        deleteScheduledTask(input.id);
+        return `🗑 Task ${input.id} deleted.`;
+    },
+};
+const webhookCreate = {
+    name: "webhook_create",
+    description: "Create a webhook endpoint. Incoming POST requests will trigger the agent with the configured prompt.",
+    input_schema: {
+        type: "object",
+        properties: {
+            name: { type: "string", description: "Webhook name." },
+            path: { type: "string", description: "URL path (e.g. 'github-push'). Will be accessible at /webhook/{path}." },
+            prompt: { type: "string", description: "Prompt template. Use {{payload}} for the request body." },
+            secret: { type: "string", description: "Optional secret for verification (sent as x-webhook-secret header)." },
+        },
+        required: ["name", "path", "prompt"],
+    },
+    execute: async (input) => {
+        const wh = createWebhook(input.name, input.path, input.prompt, input.secret);
+        return `✅ Webhook "${wh.name}" created.\nEndpoint: POST /webhook/${wh.path}\nID: ${wh.id}`;
+    },
+};
+const webhookList = {
+    name: "webhook_list",
+    description: "List all registered webhooks.",
+    input_schema: {
+        type: "object",
+        properties: {},
+        required: [],
+    },
+    execute: async () => {
+        const webhooks = listWebhooks();
+        if (webhooks.length === 0)
+            return "No webhooks registered.";
+        return webhooks.map((w) => `- "${w.name}" → POST /webhook/${w.path} (id: ${w.id})`).join("\n");
+    },
+};
+const webhookDelete = {
+    name: "webhook_delete",
+    description: "Delete a webhook endpoint.",
+    input_schema: {
+        type: "object",
+        properties: {
+            id: { type: "string", description: "Webhook ID to delete." },
+        },
+        required: ["id"],
+    },
+    execute: async (input) => {
+        deleteWebhook(input.id);
+        return `🗑 Webhook ${input.id} deleted.`;
+    },
+};
+const sessionCreate = {
+    name: "sessions_create",
+    description: "Create a new isolated agent session. Sessions have their own conversation history and optional system prompt. Use this to spawn sub-agents for parallel tasks.",
+    input_schema: {
+        type: "object",
+        properties: {
+            name: { type: "string", description: "Name for this session." },
+            system_prompt: { type: "string", description: "Optional system prompt to give the session agent a specific role or instructions." },
+        },
+        required: ["name"],
+    },
+    execute: async (input) => {
+        const session = sessionsCreate(input.name, input.system_prompt);
+        return `✅ Session "${session.name}" created (id: ${session.id})`;
+    },
+};
+const sessionList = {
+    name: "sessions_list",
+    description: "List all agent sessions.",
+    input_schema: {
+        type: "object",
+        properties: {},
+        required: [],
+    },
+    execute: async () => {
+        const sessions = sessionsList();
+        if (sessions.length === 0)
+            return "No active sessions.";
+        return sessions.map((s) => `- "${s.name}" (id: ${s.id}, last: ${s.lastActive})`).join("\n");
+    },
+};
+const sessionHistory = {
+    name: "sessions_history",
+    description: "Get the conversation history of a specific agent session.",
+    input_schema: {
+        type: "object",
+        properties: {
+            session_id: { type: "string", description: "The session ID." },
+            limit: { type: "number", description: "Max messages to return. Default: 20." },
+        },
+        required: ["session_id"],
+    },
+    execute: async (input) => {
+        const msgs = sessionsHistory(input.session_id, input.limit || 20);
+        if (msgs.length === 0)
+            return "No messages in this session.";
+        return msgs.map((m) => `[${m.role}] ${m.content}`).join("\n---\n");
+    },
+};
+const sessionSend = {
+    name: "sessions_send",
+    description: "Send a message to an agent session and get its response. The session runs its own agent loop with tools.",
+    input_schema: {
+        type: "object",
+        properties: {
+            session_id: { type: "string", description: "The session ID to send the message to." },
+            message: { type: "string", description: "The message to send." },
+        },
+        required: ["session_id", "message"],
+    },
+    execute: async (input) => {
+        const reply = await sessionsSend(input.session_id, input.message);
+        return reply;
+    },
+};
+const sessionDelete = {
+    name: "sessions_delete",
+    description: "Delete an agent session and its history.",
+    input_schema: {
+        type: "object",
+        properties: {
+            session_id: { type: "string", description: "The session ID to delete." },
+        },
+        required: ["session_id"],
+    },
+    execute: async (input) => {
+        const deleted = sessionsDelete(input.session_id);
+        return deleted ? `🗑 Session deleted.` : `⚠️ Session not found.`;
+    },
+};
+const canvasRender = {
+    name: "canvas_render",
+    description: "Push an interactive HTML/JS widget to the Live Canvas (WebChat UI). Use for tables, charts, forms, or custom HTML.",
+    input_schema: {
+        type: "object",
+        properties: {
+            widget_type: { type: "string", description: 'Type: "html", "table", "chart", or "form".', enum: ["html", "table", "chart", "form"] },
+            html: { type: "string", description: "HTML content (for html type)." },
+            js: { type: "string", description: "Optional JavaScript to execute after render." },
+            headers: { type: "array", items: { type: "string" }, description: "Column headers (for table type)." },
+            rows: { type: "array", items: { type: "array", items: { type: "string" } }, description: "Row data (for table type)." },
+        },
+        required: ["widget_type"],
+    },
+    execute: async (input) => {
+        const widgetType = input.widget_type;
+        const sockets = canvasManager.getSocketCount();
+        if (sockets === 0) {
+            return "⚠️ No active canvas connections. Open the WebChat UI to see canvas widgets.";
+        }
+        switch (widgetType) {
+            case "html":
+                canvasManager.pushHtml(input.html, input.js);
+                break;
+            case "table":
+                canvasManager.pushTable(input.headers, input.rows);
+                break;
+            case "chart":
+                canvasManager.pushChart(input);
+                break;
+            default:
+                canvasManager.pushHtml(input.html || `<p>Widget: ${widgetType}</p>`);
+        }
+        return `✅ Canvas widget (${widgetType}) pushed to ${sockets} client(s).`;
+    },
+};
+const docSaveTool = {
+    name: "doc_save",
+    description: "Save a document to the document store. Supports markdown and HTML. Documents are searchable by content and metadata.",
+    input_schema: {
+        type: "object",
+        properties: {
+            title: { type: "string", description: "Document title." },
+            content: { type: "string", description: "Document content (markdown or HTML)." },
+            category: { type: "string", description: 'Category/folder. Default: "general".' },
+            tags: { type: "array", items: { type: "string" }, description: "Tags for search." },
+            file_ext: { type: "string", description: 'File extension. Default: ".md". Options: ".md", ".html".' },
+        },
+        required: ["title", "content"],
+    },
+    execute: async (input) => {
+        const doc = await docSave(input.title, input.content, input.category || "general", input.tags || [], input.file_ext || ".md");
+        return `✅ Document saved: "${doc.title}" (id: ${doc.id}, ${doc.fileExt})`;
+    },
+};
+const docListTool = {
+    name: "doc_list",
+    description: "List documents in the document store, optionally filtered by category.",
+    input_schema: {
+        type: "object",
+        properties: {
+            category: { type: "string", description: "Optional category filter." },
+        },
+        required: [],
+    },
+    execute: async (input) => {
+        const docs = docList(input.category);
+        if (docs.length === 0)
+            return "No documents found.";
+        return docs.map((d) => `[${d.id}] "${d.title}" (${d.category}) ${d.fileExt} — ${d.updatedAt}`).join("\n");
+    },
+};
+const docReadTool = {
+    name: "doc_read",
+    description: "Read a document's content by its ID.",
+    input_schema: {
+        type: "object",
+        properties: {
+            id: { type: "number", description: "Document ID." },
+        },
+        required: ["id"],
+    },
+    execute: async (input) => {
+        const content = docRead(input.id);
+        if (!content)
+            return `⚠️ Document ${input.id} not found.`;
+        return content;
+    },
+};
+const docDeleteTool = {
+    name: "doc_delete",
+    description: "Delete a document by its ID.",
+    input_schema: {
+        type: "object",
+        properties: {
+            id: { type: "number", description: "Document ID to delete." },
+        },
+        required: ["id"],
+    },
+    execute: async (input) => {
+        const deleted = docDelete(input.id);
+        return deleted ? `🗑 Document ${input.id} deleted.` : `⚠️ Document ${input.id} not found.`;
+    },
+};
+const docSearchTool = {
+    name: "doc_search",
+    description: "Search documents by semantic similarity and keyword matching.",
+    input_schema: {
+        type: "object",
+        properties: {
+            query: { type: "string", description: "Search query." },
+            limit: { type: "number", description: "Max results. Default: 10." },
+        },
+        required: ["query"],
+    },
+    execute: async (input) => {
+        const results = await docSearch(input.query, input.limit || 10);
+        if (results.length === 0)
+            return "No documents found matching that query.";
+        return results.map((d) => `[${d.id}] "${d.title}" (${d.category}) — ${d.summary}`).join("\n");
+    },
+};
+const agentCreateTool = {
+    name: "agent_create",
+    description: "Create a new custom agent with a specific role, system prompt, and optional tool restrictions.",
+    input_schema: {
+        type: "object",
+        properties: {
+            name: { type: "string", description: "Agent name (lowercase)." },
+            role: { type: "string", description: "Short role description." },
+            system_prompt: { type: "string", description: "Full system prompt for the agent." },
+            description: { type: "string", description: "Longer description of what the agent does." },
+            tools: { type: "array", items: { type: "string" }, description: "Tools this agent can use." },
+            rules: { type: "array", items: { type: "string" }, description: "Special rules for the agent." },
+            tags: { type: "array", items: { type: "string" }, description: "Tags." },
+            team: { type: "string", description: 'Team name. Default: "custom".' },
+            model: { type: "string", description: "Primary AI model for this agent (e.g. glm-5.1, gpt-4o-mini)." },
+            fallback_model: { type: "string", description: "Fallback model if primary fails (optional)." },
+        },
+        required: ["name", "role", "system_prompt"],
+    },
+    execute: async (input) => {
+        const agent = await createAgent(input.name, input.role, input.system_prompt, {
+            description: input.description,
+            tools: input.tools,
+            rules: input.rules,
+            tags: input.tags,
+            team: input.team,
+            model: input.model,
+            fallbackModel: input.fallback_model,
+        });
+        return `✅ Agent "${agent.name}" (${agent.role}) created in team "${agent.team}".`;
+    },
+};
+const agentListTool = {
+    name: "agent_list",
+    description: "List all registered agents, optionally filtered by team.",
+    input_schema: {
+        type: "object",
+        properties: {
+            team: { type: "string", description: "Optional team filter." },
+        },
+        required: [],
+    },
+    execute: async (input) => {
+        const agents = listAgents(input.team);
+        if (agents.length === 0)
+            return "No agents found.";
+        return agents.map((a) => `[${a.team}] ${a.name} — ${a.role} ${a.builtIn ? "(built-in)" : "(custom)"}`).join("\n");
+    },
+};
+const agentShowTool = {
+    name: "agent_show",
+    description: "Show details of a specific agent by name.",
+    input_schema: {
+        type: "object",
+        properties: {
+            name: { type: "string", description: "Agent name." },
+        },
+        required: ["name"],
+    },
+    execute: async (input) => {
+        const agent = getAgent(input.name);
+        if (!agent)
+            return `⚠️ Agent "${input.name}" not found.`;
+        const lines = [
+            `**${agent.name}** (${agent.role})`,
+            `Team: ${agent.team}`,
+            `Description: ${agent.description}`,
+            `Tools: ${agent.tools.length > 0 ? agent.tools.join(", ") : "all"}`,
+            `Rules: ${agent.rules.length > 0 ? agent.rules.join("; ") : "none"}`,
+            `Tags: ${agent.tags.join(", ") || "none"}`,
+            `Built-in: ${agent.builtIn}`,
+        ];
+        return lines.join("\n");
+    },
+};
+const agentDeleteTool = {
+    name: "agent_delete",
+    description: "Delete a custom agent by name. Built-in agents cannot be deleted.",
+    input_schema: {
+        type: "object",
+        properties: {
+            name: { type: "string", description: "Agent name to delete." },
+        },
+        required: ["name"],
+    },
+    execute: async (input) => {
+        const agent = getAgent(input.name);
+        if (!agent)
+            return `⚠️ Agent "${input.name}" not found.`;
+        if (agent.builtIn)
+            return `⚠️ Cannot delete built-in agent "${input.name}".`;
+        const deleted = deleteAgent(input.name);
+        return deleted ? `🗑 Agent "${input.name}" deleted.` : `⚠️ Failed to delete agent.`;
+    },
+};
+const skillCreate = {
+    name: "skill_create",
+    description: "Create a new reusable skill from experience. Skills capture procedures, workflows, and solutions for future reuse. Create a skill after completing a complex task (5+ tool calls), fixing a tricky error, or discovering a non-trivial workflow.",
+    input_schema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "Short skill name (lowercase, hyphens). E.g. 'debug-node-errors'",
+            },
+            description: {
+                type: "string",
+                description: "Brief description of what this skill does (max 1024 chars).",
+            },
+            content: {
+                type: "string",
+                description: "Full skill instructions in markdown. Include steps, pitfalls, and verification.",
+            },
+        },
+        required: ["name", "description", "content"],
+    },
+    execute: async (input) => {
+        const result = createSkill(input.name, input.description, input.content);
+        if (result.success)
+            reloadSkills();
+        return result.success ? `✅ ${result.message}` : `⚠️ ${result.message}`;
+    },
+};
+const skillPatch = {
+    name: "skill_patch",
+    description: "Make a targeted find-and-replace edit to an existing skill. Preferred for small fixes, adding steps, or correcting outdated information. Preserves the rest of the skill.",
+    input_schema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "Skill name to patch.",
+            },
+            old: {
+                type: "string",
+                description: "Exact text to find and replace.",
+            },
+            new: {
+                type: "string",
+                description: "Replacement text.",
+            },
+            file: {
+                type: "string",
+                description: "Optional supporting file path (relative to skill dir). Defaults to SKILL.md.",
+            },
+        },
+        required: ["name", "old", "new"],
+    },
+    execute: async (input) => {
+        const result = patchSkill(input.name, input.old, input.new, input.file);
+        if (result.success)
+            reloadSkills();
+        return result.success ? `✅ ${result.message}` : `⚠️ ${result.message}`;
+    },
+};
+const skillEdit = {
+    name: "skill_edit",
+    description: "Rewrite an entire skill's instructions (the body after frontmatter). Use for major overhauls only — prefer skill_patch for small changes.",
+    input_schema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "Skill name to rewrite.",
+            },
+            content: {
+                type: "string",
+                description: "New full skill instructions in markdown.",
+            },
+        },
+        required: ["name", "content"],
+    },
+    execute: async (input) => {
+        const result = editSkill(input.name, input.content);
+        if (result.success)
+            reloadSkills();
+        return result.success ? `✅ ${result.message}` : `⚠️ ${result.message}`;
+    },
+};
+const skillDelete = {
+    name: "skill_delete",
+    description: "Delete a skill entirely. The skill and all its supporting files are removed.",
+    input_schema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "Skill name to delete.",
+            },
+        },
+        required: ["name"],
+    },
+    execute: async (input) => {
+        const result = deleteSkill(input.name);
+        if (result.success)
+            reloadSkills();
+        return result.success ? `🗑 ${result.message}` : `⚠️ ${result.message}`;
+    },
+};
+const skillView = {
+    name: "skill_view",
+    description: "View a skill's full instructions and content. Use this when you need to follow a skill's procedure. Lists supporting files if present.",
+    input_schema: {
+        type: "object",
+        properties: {
+            name: {
+                type: "string",
+                description: "Skill name to view.",
+            },
+            file: {
+                type: "string",
+                description: "Optional supporting file to view (e.g. 'references/api.md').",
+            },
+        },
+        required: ["name"],
+    },
+    execute: async (input) => {
+        const result = viewSkill(input.name, input.file);
+        return result.content;
+    },
+};
+const skillList = {
+    name: "skill_list",
+    description: "List all available skills with names and descriptions. Compact overview — use skill_view to see full instructions.",
+    input_schema: {
+        type: "object",
+        properties: {},
+        required: [],
+    },
+    execute: async () => {
+        const manualSkills = listLoadedSkills().filter((s) => s.source === "manual");
+        const agentSkills = listLoadedSkills().filter((s) => s.source === "agent");
+        if (manualSkills.length === 0 && agentSkills.length === 0) {
+            return "No skills available yet.";
+        }
+        const parts = [];
+        if (manualSkills.length > 0) {
+            parts.push("Manual skills:\n" + manualSkills.map((s) => `- 📄 ${s.name}: ${s.description}`).join("\n"));
+        }
+        if (agentSkills.length > 0) {
+            parts.push("Agent-created skills:\n" + agentSkills.map((s) => `- 🧠 ${s.name}: ${s.description}`).join("\n"));
+        }
+        return parts.join("\n\n");
+    },
+};
+const sendMessage = {
+    name: "send_message",
+    description: "Send a direct message to the user via Telegram. Use this to proactively send notifications, alerts, or responses without waiting for the user to ask. The message will be delivered immediately.",
+    input_schema: {
+        type: "object",
+        properties: {
+            message: {
+                type: "string",
+                description: "The message to send to the user via Telegram.",
+            },
+        },
+        required: ["message"],
+    },
+    execute: async (input) => {
+        const message = input.message;
+        const userId = [...config.allowedUserIds][0];
+        if (!userId) {
+            return "Error: No allowed users configured.";
+        }
+        try {
+            await sendToTelegram(userId, message);
+            return "Message sent to Telegram.";
+        }
+        catch (err) {
+            return `Failed to send message: ${err instanceof Error ? err.message : String(err)}`;
+        }
+    },
+};
+const factoryCreateTool = {
+    name: "factory_create",
+    description: "Create a new Project Factory workflow. Fredrix (Product Manager) and Stoffe (Systems Architect) will decompose the description into a DAG of tasks assigned to the right agents with dependencies. The factory orchestrator will then execute them automatically.",
+    input_schema: {
+        type: "object",
+        properties: {
+            description: {
+                type: "string",
+                description: "Project description. Be specific about what you want built.",
+            },
+        },
+        required: ["description"],
+    },
+    execute: async (input) => {
+        try {
+            const { project, tasks } = await factoryCreate(input.description);
+            const taskList = tasks
+                .map((t, i) => `${i + 1}. [${t.status}] ${t.title} → @${t.assignedAgent}${t.reviewerAgent ? ` (review: ${t.reviewerAgent})` : ""}${t.dependencies.length > 0 ? ` deps:[${t.dependencies.join(",")}]` : ""}`)
+                .join("\n");
+            return `🏭 **Factory Project Created**\n\nID: ${project.id}\nTitle: ${project.title}\nTasks: ${tasks.length}\n\n${taskList}\n\nThe factory orchestrator will start executing tasks automatically.`;
+        }
+        catch (err) {
+            return `⚠️ Factory create failed: ${err instanceof Error ? err.message : String(err)}`;
+        }
+    },
+};
+const factoryStatusTool = {
+    name: "factory_status",
+    description: "Show the status of a factory project and all its tasks (Kanban board view).",
+    input_schema: {
+        type: "object",
+        properties: {
+            project_id: { type: "number", description: "Factory project ID. If omitted, shows the latest project." },
+        },
+        required: [],
+    },
+    execute: async (input) => {
+        let project;
+        if (input.project_id) {
+            project = getFactoryProject(input.project_id);
+        }
+        else {
+            const all = listFactoryProjects();
+            project = all[0] || null;
+        }
+        if (!project)
+            return "⚠️ No factory project found.";
+        const tasks = getFactoryTasks(project.id);
+        if (tasks.length === 0)
+            return `**${project.title}** (id: ${project.id}) — No tasks.`;
+        const statusEmoji = {
+            backlog: "📋",
+            in_progress: "⚡",
+            review: "🔍",
+            done: "✅",
+            failed: "❌",
+            human_intervention: "🚨",
+        };
+        const grouped = {
+            backlog: [],
+            in_progress: [],
+            review: [],
+            done: [],
+            failed: [],
+            human_intervention: [],
+        };
+        for (const t of tasks) {
+            grouped[t.status]?.push(t);
+        }
+        const progress = project.taskCount > 0
+            ? Math.round((project.completedTasks / project.taskCount) * 100)
+            : 0;
+        const lines = [
+            `🏭 **${project.title}** (id: ${project.id})`,
+            `Status: ${project.status} | Progress: ${progress}% (${project.completedTasks}/${project.taskCount})`,
+            `Workspace: ${project.workspacePath}`,
+            "Legend: [impl]=can implement/integrate, [qa]=testing role, [rev]=code-review role, [sec]=security role",
+            "",
+        ];
+        for (const [status, statusTasks] of Object.entries(grouped)) {
+            if (statusTasks.length === 0)
+                continue;
+            lines.push(`**${statusEmoji[status] || "❓"} ${status}:**`);
+            for (const t of statusTasks) {
+                const retry = t.retryCount > 0 ? ` (retry: ${t.retryCount}/${t.maxRetries})` : "";
+                const stage = typeof t.contextPayload.stage_id === "string" ? ` [stage:${t.contextPayload.stage_id}]` : "";
+                const roleLabelMap = {
+                    code: "impl",
+                    implementation: "impl",
+                    integration: "impl",
+                    qa: "qa",
+                    review: "rev",
+                    "code-review": "rev",
+                    security: "sec",
+                };
+                const toRoleLabels = (roles) => Array.from(new Set(roles
+                    .map((r) => roleLabelMap[r] || "")
+                    .filter((r) => r.length > 0)));
+                const assignedRoles = toRoleLabels(getAgentPipelineRoles(t.assignedAgent));
+                const assignedRoleStr = assignedRoles.length > 0 ? ` [${assignedRoles.join(",")}]` : "";
+                const reviewer = t.reviewerAgent
+                    ? (() => {
+                        const reviewerRoles = toRoleLabels(getAgentPipelineRoles(t.reviewerAgent));
+                        const reviewerRoleStr = reviewerRoles.length > 0 ? ` [${reviewerRoles.join(",")}]` : "";
+                        return ` → review: ${t.reviewerAgent}${reviewerRoleStr}`;
+                    })()
+                    : "";
+                const latestFeedback = typeof t.contextPayload.latest_review_feedback === "object"
+                    && t.contextPayload.latest_review_feedback !== null
+                    ? t.contextPayload.latest_review_feedback
+                    : null;
+                const reason = latestFeedback && typeof latestFeedback.reason === "string"
+                    ? ` | reason: ${latestFeedback.reason}`
+                    : "";
+                lines.push(`  #${t.id} ${t.title}${stage} → @${t.assignedAgent}${assignedRoleStr}${reviewer}${retry}${reason}`);
+            }
+            lines.push("");
+        }
+        return lines.join("\n");
+    },
+};
+const factoryListTool = {
+    name: "factory_list",
+    description: "List all factory projects with their progress.",
+    input_schema: {
+        type: "object",
+        properties: {},
+        required: [],
+    },
+    execute: async () => {
+        const projects = listFactoryProjects();
+        if (projects.length === 0)
+            return "No factory projects yet. Use factory_create to start one.";
+        return projects
+            .map((p) => {
+            const progress = p.taskCount > 0 ? Math.round((p.completedTasks / p.taskCount) * 100) : 0;
+            return `[${p.id}] ${p.title} — ${p.status} (${progress}%, ${p.completedTasks}/${p.taskCount} tasks)`;
+        })
+            .join("\n");
+    },
+};
+const factoryPauseTool = {
+    name: "factory_pause",
+    description: "Pause a running factory project. Tasks already in progress will complete but no new ones will start.",
+    input_schema: {
+        type: "object",
+        properties: {
+            project_id: { type: "number", description: "Factory project ID to pause." },
+        },
+        required: ["project_id"],
+    },
+    execute: async (input) => {
+        const ok = setProjectStatus(input.project_id, "paused");
+        return ok ? `⏸ Factory project ${input.project_id} paused.` : `⚠️ Project ${input.project_id} not found.`;
+    },
+};
+const factoryResumeTool = {
+    name: "factory_resume",
+    description: "Resume a paused factory project.",
+    input_schema: {
+        type: "object",
+        properties: {
+            project_id: { type: "number", description: "Factory project ID to resume." },
+        },
+        required: ["project_id"],
+    },
+    execute: async (input) => {
+        const ok = setProjectStatus(input.project_id, "running");
+        return ok ? `▶️ Factory project ${input.project_id} resumed.` : `⚠️ Project ${input.project_id} not found.`;
+    },
+};
+const factoryRetryTool = {
+    name: "factory_retry",
+    description: "Force-retry a task that is stuck in human_intervention status.",
+    input_schema: {
+        type: "object",
+        properties: {
+            task_id: { type: "number", description: "Factory task ID to retry." },
+        },
+        required: ["task_id"],
+    },
+    execute: async (input) => {
+        const ok = forceRetryTask(input.task_id);
+        return ok ? `🔄 Task ${input.task_id} reset to backlog. Will be picked up on next tick.` : `⚠️ Task ${input.task_id} not found or not in human_intervention status.`;
+    },
+};
+const factoryRestartTool = {
+    name: "factory_restart",
+    description: "Restart a factory project. Default resets non-done tasks; full mode also clears the project workspace.",
+    input_schema: {
+        type: "object",
+        properties: {
+            project_id: { type: "number", description: "Factory project ID to restart." },
+            mode: { type: "string", enum: ["partial", "full"], description: "Restart mode. Default: partial." },
+        },
+        required: ["project_id"],
+    },
+    execute: async (input) => {
+        const mode = input.mode === "full" ? "full" : "partial";
+        const result = restartFactoryProject(input.project_id, mode);
+        if (!result.ok)
+            return `⚠️ ${result.message}`;
+        return `🔄 Project ${result.projectId} restarted (${result.mode}). Reset ${result.resetTasks} tasks. Workspace: ${result.workspacePath}`;
+    },
+};
+export function buildTools() {
+    const base = [
+        getCurrentTime,
+        remember,
+        recall,
+        forget,
+        searchConversationsTool,
+        speak,
+        knowledgeAdd,
+        knowledgeQuery,
+        scheduleTask,
+        scheduleList,
+        scheduleToggle,
+        scheduleDelete,
+        webhookCreate,
+        webhookList,
+        webhookDelete,
+        sessionCreate,
+        sessionList,
+        sessionHistory,
+        sessionSend,
+        sessionDelete,
+        canvasRender,
+        docSaveTool,
+        docListTool,
+        docReadTool,
+        docDeleteTool,
+        docSearchTool,
+        agentCreateTool,
+        agentListTool,
+        agentShowTool,
+        agentDeleteTool,
+        skillCreate,
+        skillPatch,
+        skillEdit,
+        skillDelete,
+        skillView,
+        skillList,
+        shellExec,
+        ...configTools,
+        ...fileTools,
+        browser,
+        webSearch,
+        sendMessage,
+        factoryCreateTool,
+        factoryStatusTool,
+        factoryListTool,
+        factoryPauseTool,
+        factoryResumeTool,
+        factoryRetryTool,
+        factoryRestartTool,
+    ];
+    const mcpTools = getMCPTools();
+    return [...base, ...mcpTools];
+}
+export const tools = [];
+export function initializeTools() {
+    const built = buildTools();
+    tools.length = 0;
+    tools.push(...built);
+    console.log(`🔧 ${tools.length} tools registered`);
+}
+export function getTool(name) {
+    return tools.find((t) => t.name === name);
+}
+//# sourceMappingURL=index.js.map