@kolisachint/hoocode-agent 0.4.100 → 0.4.102

package/dist/extensions/core/hoo-core.js

@@ -15,7 +15,7 @@
  *   2. ./.hoocode/hoo-config.json   (project overrides — scalars win; arrays union)
  */
 import { spawn } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { readdir } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join, relative } from "node:path";
@@ -23,9 +23,12 @@ import { createInterface } from "node:readline";
 import { Text } from "@kolisachint/hoocode-tui";
 import { Type } from "typebox";
 import { getHooCodeDir } from "../../config.js";
-import { isToolCallEventType } from "../../core/extensions/types.js";
+import { getExtensionMcpServers } from "../../core/extension-mcp-servers.js";
+import { parseMarketplaceDir, readMarketplaceStore, resolvePluginSource, writeMarketplaceStore, } from "../../core/extensions/plugins/marketplace.js";
+import { defineTool, isToolCallEventType } from "../../core/extensions/types.js";
 import { summarizeArgs } from "../../core/messages.js";
 import { DEFAULT_MODE, DEFAULT_MODE_PROMPTS as MODE_DEFAULTS } from "../../core/mode-prompts.js";
+import { TaskScheduler } from "../../core/scheduler.js";
 import { subagentSkipMcp } from "../../core/subagent-depth.js";
 import { taskStore } from "../../core/task-store.js";
 import { blockedHostForUrl } from "../../core/tools/webtools-shared.js";
@@ -570,6 +573,15 @@ export function setupMcpLoader(pi) {
                 allServerConfigs.push(serverConfig);
             }
         }
+        // 2b. Load from plugins/extensions that registered MCP servers during load.
+        for (const entry of getExtensionMcpServers()) {
+            for (const serverConfig of parseStandardMcpConfig({ mcpServers: entry.mcpServers }, `plugin:${entry.source}`)) {
+                if (seenNames.has(serverConfig.name))
+                    continue;
+                seenNames.add(serverConfig.name);
+                allServerConfigs.push(serverConfig);
+            }
+        }
         // 3. Connect to all servers and register tools
         for (const serverConfig of allServerConfigs) {
             // Retain the config so a tool call can lazily reconnect a dropped server.
@@ -1253,6 +1265,401 @@ export function setupThinkingEscalation(pi) {
     });
 }
 // ============================================================================
+// /loop — cron scheduler, Cron* tools, and autonomous continuation
+// ============================================================================
+const AUTO_LOOP_DONE_TOKEN = "LOOP_DONE";
+const DEFAULT_AUTO_MAX_TURNS = 10;
+/** Convert a simple interval token ("5m", "2h", "1d") to a 5-field cron, or null. */
+function intervalToCron(token) {
+    const m = /^(\d+)(m|h|d)$/.exec(token.trim());
+    if (!m)
+        return null;
+    const n = Number(m[1]);
+    if (n < 1)
+        return null;
+    if (m[2] === "m")
+        return `*/${n} * * * *`;
+    if (m[2] === "h")
+        return `0 */${n} * * *`;
+    return `0 0 */${n} * *`; // days
+}
+/** Pull a quoted cron expression off the front of an argument string. */
+function extractQuotedCron(args) {
+    const m = /^"([^"]+)"\s*(.*)$/.exec(args.trim());
+    return m ? { cron: m[1].trim(), rest: m[2].trim() } : null;
+}
+function isFiveFieldCron(expr) {
+    return expr.trim().split(/\s+/).length === 5;
+}
+/** Flatten an assistant message's text blocks. */
+function assistantText(message) {
+    const content = message.content;
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((b) => !!b && b.type === "text")
+        .map((b) => b.text)
+        .join("\n");
+}
+/**
+ * `/loop` schedules prompts via cron and drives autonomous continuation. The same
+ * scheduler backs the agent-callable CronCreate/CronList/CronDelete tools.
+ *
+ *   /loop "<cron>" <prompt>     schedule recurring (5-field cron, local time)
+ *   /loop <5m|2h|1d> <prompt>   schedule recurring at a simple interval
+ *   /loop once "<cron>" <prompt>  schedule a one-shot
+ *   /loop list | /loop delete <id> | /loop stop
+ *   /loop auto [--max-turns N] <task>   keep iterating until the task says LOOP_DONE
+ */
+export function setupLoop(pi) {
+    let scheduler;
+    let auto = null;
+    pi.on("session_start", (_event, ctx) => {
+        if (scheduler)
+            return;
+        const isIdle = () => {
+            try {
+                return ctx.isIdle();
+            }
+            catch {
+                return true;
+            }
+        };
+        scheduler = new TaskScheduler({
+            storePath: join(ctx.cwd, ".hoocode", "scheduled_tasks.json"),
+            fire: (prompt) => pi.sendUserMessage(prompt, { deliverAs: "followUp" }),
+            isIdle,
+        });
+        scheduler.start();
+    });
+    pi.on("session_shutdown", () => {
+        scheduler?.stop();
+        auto = null;
+    });
+    // Autonomous continuation: re-prompt on each agent_end until LOOP_DONE or budget.
+    pi.on("agent_end", (event, ctx) => {
+        if (!auto)
+            return;
+        if (ctx.hasPendingMessages())
+            return; // user is steering — yield
+        const last = [...event.messages].reverse().find((m) => m.role === "assistant");
+        const text = last ? assistantText(last) : "";
+        if (text.includes(AUTO_LOOP_DONE_TOKEN)) {
+            auto = null;
+            ctx.ui.notify("Autonomous loop complete.", "info");
+            return;
+        }
+        if (auto.remaining <= 0) {
+            auto = null;
+            ctx.ui.notify("Autonomous loop stopped: max turns reached.", "warning");
+            return;
+        }
+        auto.remaining -= 1;
+        pi.sendUserMessage(`Continue working toward the goal. Reply with ${AUTO_LOOP_DONE_TOKEN} when fully complete.`, {
+            deliverAs: "followUp",
+        });
+    });
+    // ── Cron* tools (agent-callable) ──────────────────────────────────────────
+    const toolText = (s) => ({ content: [{ type: "text", text: s }], details: undefined });
+    pi.registerTool(defineTool({
+        name: "CronCreate",
+        label: "Schedule Task",
+        description: "Schedule a prompt to be re-submitted on a cron schedule (5-field, local time: minute hour day-of-month month day-of-week). recurring=false fires once then deletes.",
+        parameters: Type.Object({
+            cron: Type.String({ description: "5-field cron expression in local time" }),
+            prompt: Type.String({ description: "Prompt to enqueue at each fire time" }),
+            recurring: Type.Optional(Type.Boolean({ description: "Fire repeatedly (default true) or once" })),
+        }),
+        async execute(_id, params) {
+            if (!scheduler)
+                return toolText("Scheduler not ready.");
+            if (!isFiveFieldCron(params.cron))
+                return toolText(`Invalid cron "${params.cron}" (need 5 fields).`);
+            const task = scheduler.create({
+                cron: params.cron,
+                prompt: params.prompt,
+                recurring: params.recurring ?? true,
+            });
+            return toolText(`Scheduled ${task.id}: "${task.cron}" (${task.recurring ? "recurring" : "once"})`);
+        },
+    }));
+    pi.registerTool(defineTool({
+        name: "CronList",
+        label: "List Scheduled Tasks",
+        description: "List all scheduled tasks (id, cron, recurring, prompt).",
+        parameters: Type.Object({}),
+        async execute() {
+            const tasks = scheduler?.list() ?? [];
+            if (tasks.length === 0)
+                return toolText("No scheduled tasks.");
+            return toolText(tasks
+                .map((t) => `${t.id}  ${t.cron}  ${t.recurring ? "recurring" : "once"}  ${JSON.stringify(t.prompt)}`)
+                .join("\n"));
+        },
+    }));
+    pi.registerTool(defineTool({
+        name: "CronDelete",
+        label: "Delete Scheduled Task",
+        description: "Delete a scheduled task by id.",
+        parameters: Type.Object({ id: Type.String({ description: "Task id from CronCreate/CronList" }) }),
+        async execute(_id, params) {
+            const removed = scheduler?.delete(params.id) ?? false;
+            return toolText(removed ? `Deleted ${params.id}.` : `No task ${params.id}.`);
+        },
+    }));
+    // ── /loop command ─────────────────────────────────────────────────────────
+    pi.registerCommand("loop", {
+        description: 'Schedule prompts via cron or run an autonomous loop. /loop "<cron>" <prompt> | /loop <5m|2h> <prompt> | /loop once "<cron>" <prompt> | /loop list | /loop delete <id> | /loop stop | /loop auto [--max-turns N] <task>',
+        getArgumentCompletions: (prefix) => ["list", "delete", "stop", "once", "auto"]
+            .filter((s) => s.startsWith(prefix))
+            .map((s) => ({ value: s, label: s })),
+        handler: async (args, ctx) => {
+            const trimmed = args.trim();
+            if (!scheduler) {
+                ctx.ui.notify("Scheduler not ready yet.", "warning");
+                return;
+            }
+            if (!trimmed || trimmed === "list") {
+                const tasks = scheduler.list();
+                ctx.ui.notify(tasks.length === 0
+                    ? auto
+                        ? `Autonomous loop active (${auto.remaining} turns left).`
+                        : "No scheduled tasks."
+                    : tasks.map((t) => `${t.id}: ${t.cron} ${t.recurring ? "" : "(once) "}— ${t.prompt}`).join("\n"), "info");
+                return;
+            }
+            if (trimmed === "stop") {
+                const had = scheduler.list().length > 0 || auto !== null;
+                scheduler.clear();
+                auto = null;
+                ctx.ui.notify(had ? "Stopped all loops and scheduled tasks." : "Nothing to stop.", "info");
+                return;
+            }
+            if (trimmed.startsWith("delete")) {
+                const id = trimmed.slice("delete".length).trim();
+                if (!id) {
+                    ctx.ui.notify("Usage: /loop delete <id>", "warning");
+                    return;
+                }
+                ctx.ui.notify(scheduler.delete(id) ? `Deleted ${id}.` : `No task ${id}.`, "info");
+                return;
+            }
+            if (trimmed.startsWith("auto")) {
+                let rest = trimmed.slice("auto".length).trim();
+                let maxTurns = DEFAULT_AUTO_MAX_TURNS;
+                const flag = /^--max-turns\s+(\d+)\s*(.*)$/.exec(rest);
+                if (flag) {
+                    maxTurns = Number(flag[1]);
+                    rest = flag[2].trim();
+                }
+                if (!rest) {
+                    ctx.ui.notify("Usage: /loop auto [--max-turns N] <task>", "warning");
+                    return;
+                }
+                auto = { remaining: maxTurns };
+                pi.sendUserMessage(`${rest}\n\n(Autonomous loop: keep working until the task is fully complete, then reply with ${AUTO_LOOP_DONE_TOKEN}.)`, { deliverAs: "followUp" });
+                ctx.ui.notify(`Autonomous loop started (max ${maxTurns} turns). Stop with /loop stop.`, "info");
+                return;
+            }
+            // Scheduling: one-shot or recurring, via quoted cron or interval token.
+            let recurring = true;
+            let body = trimmed;
+            if (body.startsWith("once")) {
+                recurring = false;
+                body = body.slice("once".length).trim();
+            }
+            let cron = null;
+            let prompt = "";
+            const quoted = extractQuotedCron(body);
+            if (quoted) {
+                cron = quoted.cron;
+                prompt = quoted.rest;
+            }
+            else {
+                const [first, ...restWords] = body.split(/\s+/);
+                cron = intervalToCron(first);
+                prompt = restWords.join(" ").trim();
+            }
+            if (!cron || !isFiveFieldCron(cron)) {
+                ctx.ui.notify('Usage: /loop "<cron>" <prompt>  or  /loop <5m|2h|1d> <prompt>', "warning");
+                return;
+            }
+            if (!prompt) {
+                ctx.ui.notify("Nothing to schedule — provide a prompt after the schedule.", "warning");
+                return;
+            }
+            const task = scheduler.create({ cron, prompt, recurring });
+            ctx.ui.notify(`Scheduled ${task.id}: "${cron}" ${recurring ? "recurring" : "once"} — "${prompt}". Manage with /loop list • /loop delete ${task.id}.`, "info");
+        },
+    });
+}
+// ============================================================================
+// /plugin — marketplace add/list + plugin install/list/remove
+// ============================================================================
+function sanitizeForDir(s) {
+    return s.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 80);
+}
+function isGitSource(loc) {
+    return /^https?:\/\//.test(loc) || loc.startsWith("git@") || loc.endsWith(".git");
+}
+/**
+ * `/plugin` installs plugins from marketplaces (a git repo or local dir with a
+ * Claude `.claude-plugin/marketplace.json` or Copilot-style `.github/marketplace.json`
+ * index). Installed plugins are placed in `.hoocode/plugins/<name>` and loaded by the
+ * plugin loader after a reload.
+ *
+ *   /plugin marketplace add <git-url|path>
+ *   /plugin marketplace list
+ *   /plugin list                     list available plugins across marketplaces
+ *   /plugin install <name>
+ *   /plugin remove <name>
+ */
+export function setupMarketplace(pi) {
+    const storePath = (cwd) => join(cwd, ".hoocode", "marketplaces.json");
+    const pluginsDir = (cwd) => join(cwd, ".hoocode", "plugins");
+    const cacheDir = (cwd) => join(cwd, ".hoocode", "marketplace-cache");
+    const findPlugin = (cwd, name) => {
+        for (const record of readMarketplaceStore(storePath(cwd))) {
+            const market = parseMarketplaceDir(record.dir);
+            const entry = market?.plugins.find((p) => p.name === name);
+            if (market && entry)
+                return { market, entry };
+        }
+        return undefined;
+    };
+    pi.registerCommand("plugin", {
+        description: "Manage plugin marketplaces. /plugin marketplace add <git-url|path> | /plugin marketplace list | /plugin list | /plugin install <name> | /plugin remove <name>",
+        getArgumentCompletions: (prefix) => ["marketplace", "list", "install", "remove"]
+            .filter((s) => s.startsWith(prefix))
+            .map((s) => ({ value: s, label: s })),
+        handler: async (args, ctx) => {
+            const trimmed = args.trim();
+            const cwd = ctx.cwd;
+            // ── marketplace add / list ──────────────────────────────────────────
+            if (trimmed.startsWith("marketplace")) {
+                const sub = trimmed.slice("marketplace".length).trim();
+                if (sub === "list" || sub === "") {
+                    const records = readMarketplaceStore(storePath(cwd));
+                    if (records.length === 0) {
+                        ctx.ui.notify("No marketplaces. Add one with /plugin marketplace add <git-url|path>.", "info");
+                        return;
+                    }
+                    const lines = records.map((r) => {
+                        const market = parseMarketplaceDir(r.dir);
+                        return `${market?.name ?? r.location} — ${market?.plugins.length ?? 0} plugin(s) [${r.location}]`;
+                    });
+                    ctx.ui.notify(lines.join("\n"), "info");
+                    return;
+                }
+                if (sub.startsWith("add")) {
+                    const loc = sub.slice("add".length).trim();
+                    if (!loc) {
+                        ctx.ui.notify("Usage: /plugin marketplace add <git-url|path>", "warning");
+                        return;
+                    }
+                    let dir;
+                    if (isGitSource(loc)) {
+                        dir = join(cacheDir(cwd), sanitizeForDir(loc));
+                        rmSync(dir, { recursive: true, force: true });
+                        mkdirSync(cacheDir(cwd), { recursive: true });
+                        const res = await pi.exec("git", ["clone", "--depth", "1", loc, dir]);
+                        if (res.code !== 0) {
+                            ctx.ui.notify(`Clone failed: ${res.stderr || res.stdout}`, "error");
+                            return;
+                        }
+                    }
+                    else {
+                        dir = resolvePluginSource(loc, cwd).kind === "local" ? join(cwd, loc) : loc;
+                        if (!existsSync(dir)) {
+                            ctx.ui.notify(`Path not found: ${dir}`, "error");
+                            return;
+                        }
+                    }
+                    const market = parseMarketplaceDir(dir);
+                    if (!market) {
+                        ctx.ui.notify("No marketplace manifest found (.claude-plugin/ or .github/marketplace.json).", "error");
+                        return;
+                    }
+                    const records = readMarketplaceStore(storePath(cwd)).filter((r) => r.location !== loc);
+                    records.push({ location: loc, dir });
+                    writeMarketplaceStore(storePath(cwd), records);
+                    ctx.ui.notify(`Added marketplace "${market.name}" (${market.plugins.length} plugin(s)).`, "info");
+                    return;
+                }
+                ctx.ui.notify("Usage: /plugin marketplace add <git-url|path> | /plugin marketplace list", "warning");
+                return;
+            }
+            // ── list available plugins ──────────────────────────────────────────
+            if (trimmed === "list" || trimmed === "") {
+                const records = readMarketplaceStore(storePath(cwd));
+                const lines = [];
+                for (const record of records) {
+                    const market = parseMarketplaceDir(record.dir);
+                    for (const p of market?.plugins ?? []) {
+                        lines.push(`${p.name} — ${p.description ?? p.source}`);
+                    }
+                }
+                ctx.ui.notify(lines.length ? lines.join("\n") : "No plugins available. Add a marketplace first.", "info");
+                return;
+            }
+            // ── install <name> ──────────────────────────────────────────────────
+            if (trimmed.startsWith("install")) {
+                const name = trimmed.slice("install".length).trim();
+                if (!name) {
+                    ctx.ui.notify("Usage: /plugin install <name>", "warning");
+                    return;
+                }
+                const found = findPlugin(cwd, name);
+                if (!found) {
+                    ctx.ui.notify(`Plugin "${name}" not found in any marketplace.`, "error");
+                    return;
+                }
+                const resolved = resolvePluginSource(found.entry.source, found.market.root);
+                const dest = join(pluginsDir(cwd), sanitizeForDir(name));
+                rmSync(dest, { recursive: true, force: true });
+                mkdirSync(pluginsDir(cwd), { recursive: true });
+                if (resolved.kind === "local") {
+                    cpSync(resolved.path, dest, { recursive: true });
+                }
+                else if (resolved.kind === "git") {
+                    const res = await pi.exec("git", ["clone", "--depth", "1", resolved.url, dest]);
+                    if (res.code !== 0) {
+                        ctx.ui.notify(`Clone failed: ${res.stderr || res.stdout}`, "error");
+                        return;
+                    }
+                }
+                else {
+                    ctx.ui.notify(`npm plugin sources are not supported yet (${resolved.spec}).`, "warning");
+                    return;
+                }
+                ctx.ui.notify(`Installed "${name}" — reloading…`, "info");
+                await ctx.reload();
+                return;
+            }
+            // ── remove <name> ───────────────────────────────────────────────────
+            if (trimmed.startsWith("remove")) {
+                const name = trimmed.slice("remove".length).trim();
+                if (!name) {
+                    ctx.ui.notify("Usage: /plugin remove <name>", "warning");
+                    return;
+                }
+                const dest = join(pluginsDir(cwd), sanitizeForDir(name));
+                if (!existsSync(dest)) {
+                    ctx.ui.notify(`Plugin "${name}" is not installed.`, "info");
+                    return;
+                }
+                rmSync(dest, { recursive: true, force: true });
+                ctx.ui.notify(`Removed "${name}" — reloading…`, "info");
+                await ctx.reload();
+                return;
+            }
+            ctx.ui.notify("Usage: /plugin marketplace add|list | /plugin list | /plugin install <name> | /plugin remove <name>", "warning");
+        },
+    });
+}
+// ============================================================================
 // Extension entry point
 // ============================================================================
 function hooCore(pi) {
@@ -1262,6 +1669,8 @@ function hooCore(pi) {
     setupScaffold(pi);
     setupAskOptions(pi);
     setupThinkingEscalation(pi);
+    setupLoop(pi);
+    setupMarketplace(pi);
 }
 hooCore.displayName = "hoo-core";
 export default hooCore;