agent-from-zero 0.32.4 → 0.34.0

package/dist/agent.js

@@ -8,10 +8,11 @@ import { runLoop, TerminateReason, MAX_RETRIES, killAllSubAgents } from "./loop.
 import { buildSystemMessage } from "./prompt.js"; // the constitution + optional AGENT.md project memory
 import { forgetFilesExcept, registerExternalTool } from "./tools.js"; // file-state reset + tool registration
 import { compactHistory, estimateHistoryTokens, COMPACT_AT } from "./context.js"; // for the manual /compact command
-import { newSessionId, saveSession, latestSession, listSessions, loadSession } from "./session.js"; // conversation persistence (project-local) + the /resume picker
+import { newSessionId, saveSession, latestSession, listSessions, loadSession, setSessionTitle } from "./session.js"; // conversation persistence (project-local) + the /resume picker
+import { generateSessionTitle } from "./title.js"; // concise session name, generated after the first message
 import { initTelemetry, emit, statsReport } from "./telemetry.js"; // local-only event log + /stats
 import { runHooks } from "./hooks.js"; // SessionStart lifecycle hook
-import { connectMcpServers } from "./mcp.js"; // external tool servers (MCP)
+import { connectMcpServers, listMcpServers, mcpActionsFor, runMcpAction } from "./mcp.js"; // external tool servers (MCP) + /mcp
 import { Judge } from "./judge.js"; // optional LLM permission classifier
 import { isPlanMode, setPlanMode } from "./permissions.js"; // plan mode: research-only until the user approves a plan
 import { undoLast, clearUndo, sessionChanges } from "./undo.js"; // /undo + /diff: take back, or review, this session's writes
@@ -31,6 +32,7 @@ import { launchInk } from "./ink/launch.js"; // the Ink REPL — the default fro
 import { listBackground, hasRunningBackground, killAllBackground } from "./background.js"; // background tasks: /bg view + kill-on-exit (Day 37)
 import { listTeam, resetTeam } from "./team.js"; // agent teams: /team view + reset on clear/resume (Day 38)
 import { boardSummary, resetBoard } from "./board.js"; // task board: /tasks view + reset on clear/resume (Day 40)
+import { loadDurableJobs, startCronScheduler, stopCronScheduler, listJobs } from "./cron.js"; // cron scheduler (Day s14)
 // package.json sits one level above both src/ (dev) and dist/ (built) — same path either way.
 const pkg = createRequire(import.meta.url)("../package.json");
 // ---- CLI arguments --------------------------------------------------------------
@@ -70,11 +72,13 @@ const SESSION_HELP = `commands:
   /stats     event counts for this session (local telemetry — nothing leaves this machine)
   /memory    show the durable facts the agent remembers about this project
   /cost      tokens, cache hit rate and estimated spend this session (local)
+  /mcp       list configured MCP servers + status; select one to authenticate / reconnect / disable
   /plan      toggle plan mode — research-only; the agent presents a plan you approve before any change
   /todos     show the agent's current task plan (it maintains one with todo_write on multi-step work)
   /bg        list background tasks this session (run_bash_background) and their status
   /team      list the agent team (spawn_teammate): each teammate's role, status, and pending inbox
   /tasks     show the shared task board (create_task/claim_task): each task's status, owner, and dependencies
+  /cron      list scheduled cron jobs (schedule_cron) and their expressions
   /undo      revert the most recent file write (write_file / edit_file) this session
   /diff      show every file changed this session, as a diff from where it started
   /resume    list recent sessions in this project and continue one of them
@@ -156,6 +160,13 @@ async function main() {
     process.on("exit", disconnectMcp); // best-effort cleanup of server subprocesses
     process.on("exit", killAllBackground); // Day 37: SIGKILL any background job (dev server, slow install) so it never outlives the agent as an orphan
     process.on("exit", killAllSubAgents); // mark any still-running sub-agents as killed so they don't leave pending promises
+    process.on("exit", stopCronScheduler); // Day s14: stop the setInterval on exit
+    // Cron scheduler (Day s14): restore durable jobs from disk, start the 1s poll.
+    loadDurableJobs();
+    const cronCount = listJobs().length;
+    if (cronCount)
+        console.log(chalk.dim(`(cron: ${cronCount} durable job${cronCount !== 1 ? "s" : ""} loaded)`));
+    startCronScheduler();
     // The optional LLM permission judge, built once if a settings file enabled it.
     const judge = CONFIG.judge.enabled ? new Judge(client, CONFIG.judge.model || CONFIG.model) : undefined;
     if (judge)
@@ -192,6 +203,8 @@ async function main() {
     let running = false; // is a task currently executing?
     let interrupted = false; // has the current task been interrupted?
     let controller = new AbortController(); // aborts the in-flight API request
+    let titleAttempted = false; // one-shot: name the session once, after the first real message
+    let pendingTitle; // the generated title, passed into the next save
     // ---- One-shot print mode -------------------------------------------------------
     // The same loop, the same permission gate (fail closed without a TTY), no REPL.
     // Designed for scripts: the exit code distinguishes success from every failure.
@@ -400,6 +413,51 @@ async function main() {
         }
         apply(models[choice]); // picker is session-only too; "/model save <name>" to persist
     };
+    // /mcp — list configured MCP servers + status, then manage one (like Claude Code).
+    const mcpStatusText = (status) => status === "connected" ? chalk.green("connected") : status === "needs-auth" ? chalk.yellow("needs auth") : status === "failed" ? chalk.red("failed") : chalk.dim("disabled");
+    const handleMcpCommand = async (arg) => {
+        const parts = arg.trim().split(/\s+/).filter(Boolean);
+        if (parts.length >= 2 && ["reconnect", "auth", "authenticate", "enable", "disable"].includes(parts[0])) {
+            const name = parts.slice(1).join(" ");
+            const action = parts[0] === "auth" || parts[0] === "authenticate" ? "authenticate" : parts[0];
+            try {
+                console.log(chalk.dim(await runMcpAction(name, action, (url) => console.log(chalk.dim(`authenticate in your browser: ${url}`)))));
+            }
+            catch (err) {
+                console.log(chalk.yellow(err.message));
+            }
+            return;
+        }
+        const servers = listMcpServers();
+        if (!servers.length) {
+            console.log(chalk.dim("(no MCP servers configured — add an mcpServers map to .mini-agent/settings.json or ~/.config/mini-agent/settings.json)"));
+            return;
+        }
+        console.log(chalk.dim("MCP servers:"));
+        const labels = servers.map((s) => `${s.name}  ·  ${mcpStatusText(s.status)}${s.tools ? `  ·  ${s.tools} tool${s.tools === 1 ? "" : "s"}` : ""}${s.transport === "http" ? "  ·  http" : "  ·  stdio"}`);
+        for (const label of labels)
+            console.log(chalk.dim(`  ${label}`));
+        if (!process.stdin.isTTY)
+            return;
+        const choice = await promptSelect(rl, labels.map((l) => l.replace(/  ·  /g, " — ")));
+        if (choice < 0) {
+            console.log(chalk.dim("(cancelled)"));
+            return;
+        }
+        const server = servers[choice];
+        const actions = mcpActionsFor(server);
+        const actionChoice = await promptSelect(rl, actions.map((a) => a.label));
+        if (actionChoice < 0) {
+            console.log(chalk.dim("(cancelled)"));
+            return;
+        }
+        try {
+            console.log(chalk.dim(await runMcpAction(server.name, actions[actionChoice].action, (url) => console.log(chalk.dim(`authenticate in your browser: ${url}`)))));
+        }
+        catch (err) {
+            console.log(chalk.yellow(err.message));
+        }
+    };
     // Handle a /slash command. Returns true if the line was a command.
     const handleCommand = async (line) => {
         // /model takes an optional argument (/model <name>), so it can't be a plain
@@ -433,6 +491,11 @@ async function main() {
                 console.log(chalk.yellow(`\n⚠️ ${EXIT_NOTES[r.reason]}`));
             return true;
         }
+        // /mcp [reconnect|auth|enable|disable <name>]
+        if (line === "/mcp" || line.startsWith("/mcp ")) {
+            await handleMcpCommand(line.slice("/mcp".length).trim());
+            return true;
+        }
         switch (line) {
             case "/skills": {
                 if (!skills.length) {
@@ -459,6 +522,8 @@ async function main() {
                 clearReasoning(); // drop the collapsed thinking too
                 clearToolCalls(); // ...and the folded tool-call trace
                 sessionId = newSessionId(); // a fresh conversation is a fresh session file
+                titleAttempted = false; // a fresh session gets its own title on its first message
+                pendingTitle = undefined;
                 console.log(chalk.dim("(history cleared)")); // confirm the reset
                 return true;
             case "/todos": {
@@ -505,6 +570,20 @@ async function main() {
                 console.log(summary === "(the task board is empty)" ? chalk.dim("(no tasks — the lead adds them with create_task; teammates claim them autonomously)") : chalk.dim(`task board:\n${summary}`));
                 return true;
             }
+            case "/cron": {
+                // Scheduled cron jobs (schedule_cron): list all currently registered.
+                const jobs = listJobs();
+                if (!jobs.length) {
+                    console.log(chalk.dim("(no cron jobs scheduled)"));
+                }
+                else {
+                    console.log(chalk.dim(`cron jobs (${jobs.length}):`));
+                    for (const j of jobs) {
+                        console.log(chalk.dim(`  ${j.id}  "${j.cron}"  → "${j.prompt}"${j.recurring ? " (recurring)" : " (one-shot)"}${j.durable ? " (durable)" : " (session-only)"}`));
+                    }
+                }
+                return true;
+            }
             case "/stats":
                 console.log(chalk.dim(statsReport())); // local counters, busiest first
                 return true;
@@ -566,6 +645,8 @@ async function main() {
                 }
                 messages = [{ role: "system", content: systemMessage }, ...chosen.messages]; // fresh constitution + saved turns
                 sessionId = chosen.id; // keep appending to the resumed session's file
+                titleAttempted = false; // a resumed session without a title gets one on its next message
+                pendingTitle = chosen.title;
                 forgetFilesExcept([]); // a resumed conversation must re-read files before editing them
                 clearUndo(); // the previous session's writes are not ours to undo
                 clearTodos(); // the resumed task starts without the old session's stale plan
@@ -690,6 +771,22 @@ async function main() {
             console.log(chalk.dim(`(attached ${attached.length} file${attached.length === 1 ? "" : "s"}: ${attached.join(", ")})`));
         if (refused.length)
             console.log(chalk.yellow(`(refused secret file${refused.length === 1 ? "" : "s"}: ${refused.join(", ")})`));
+        // Name the session once, after the first real user message. Same as the Ink
+        // REPL: a cheap model call distills the prompt into a 3-7 word title, fired
+        // and forgotten so it never delays the turn; a failure leaves the raw prompt.
+        if (!titleAttempted) {
+            titleAttempted = true;
+            if (!loadSession(sessionId)?.title) {
+                void generateSessionTitle(client, CONFIG.subAgentModel || CONFIG.model, line)
+                    .then((title) => {
+                    if (title) {
+                        pendingTitle = title;
+                        setSessionTitle(sessionId, title);
+                    }
+                })
+                    .catch(() => { });
+            }
+        }
         messages.push({ role: "user", content: augmented + injected }); // the new turn (with any attached files + hook context) joins the shared history
         clearReasoning(); // Ctrl+R should reveal THIS turn's thinking, not the previous answer's
         clearToolCalls(); // ...and Ctrl+T should reveal THIS turn's tool calls
@@ -707,7 +804,7 @@ async function main() {
             judge, // optional LLM classifier for the "ask" middle ground
         });
         running = false; // back at the prompt — Ctrl+C means "exit" again
-        saveSession(sessionId, CONFIG.model, messages); // snapshot after every turn — crash-safe by construction
+        saveSession(sessionId, CONFIG.model, messages, pendingTitle); // snapshot after every turn — crash-safe by construction
         // Auto-extract memories (opt-in: settings.memory.autoExtract). A cheap pass
         // that saves durable facts — especially user corrections — so memory
         // captures itself instead of relying on the model to call `remember`.

package/dist/cron.js

@@ -0,0 +1,280 @@
+// ============ Cron Scheduler (Day s14) ============
+// The problem: the agent only acts when the user says something. "Run tests every
+// morning at 9" or "Check CI every 30 minutes" shouldn't need a human to push.
+//
+// Solution, mirroring Claude Code: an independent scheduler that checks cron
+// expressions every second, a queue that holds triggered jobs, and a queue
+// processor that delivers them when the agent is idle. Four layers:
+//
+//   Scheduler    — setInterval, 1s poll, writes to cron_queue
+//   Queue        — cron_queue, the handoff from scheduler to processor
+//   Queue Proc.  — watches cron_queue; when non-empty + agent idle, triggers a turn
+//   Consumer     — runLoop consumes cron_queue, injects "[Scheduled] ..." messages
+//
+// Durable jobs are written to .mini-agent/scheduled_tasks.json and survive
+// restarts (the scheduler re-loads them next time). Session-only jobs live only
+// in memory — when the process exits, they are gone.
+import fs from "node:fs";
+import path from "node:path";
+const SCHEDULED_TASKS_FILE = ".mini-agent/scheduled_tasks.json";
+const MAX_JOBS = 50;
+// In-memory registry: all jobs scheduled this session.
+const scheduledJobs = new Map();
+// The handoff: scheduler writes here, consumer drains.
+const cronQueue = [];
+// Prevent the scheduler from firing the same job twice in the same minute.
+const lastFired = new Map(); // job id → "YYYY-MM-DD HH:MM"
+// Lock for the cron queue and scheduled jobs map.
+let cronLock = false;
+function withCronLock(fn) {
+    // Node is single-threaded, so this lock is simpler than a real mutex.
+    // It's here for correctness compatibility with the Python reference.
+    cronLock = true;
+    try {
+        return fn();
+    }
+    finally {
+        cronLock = false;
+    }
+}
+// ============ Cron expression matching ============
+// Standard 5-field cron: minute hour day-of-month month day-of-week.
+// Day-of-month AND day-of-week both constrained → OR semantics (either matches).
+function cronFieldMatches(field, value) {
+    if (field === "*")
+        return true;
+    // Comma-separated list: "1,3,5"
+    const parts = field.split(",");
+    for (const part of parts) {
+        if (part.includes("/")) {
+            // Step: "*/5" or "0/5"
+            const [base, stepStr] = part.split("/");
+            const step = parseInt(stepStr, 10);
+            if (isNaN(step) || step < 1)
+                continue;
+            if (base === "*") {
+                if (value % step === 0)
+                    return true;
+            }
+            else {
+                const start = parseInt(base, 10);
+                if (!isNaN(start) && value >= start && (value - start) % step === 0)
+                    return true;
+            }
+        }
+        else if (part.includes("-")) {
+            // Range: "1-5"
+            const [lo, hi] = part.split("-").map(Number);
+            if (!isNaN(lo) && !isNaN(hi) && value >= lo && value <= hi)
+                return true;
+        }
+        else {
+            // Exact: "5"
+            if (parseInt(part, 10) === value)
+                return true;
+        }
+    }
+    return false;
+}
+export function cronMatches(cronExpr, dt) {
+    const fields = cronExpr.trim().split(/\s+/);
+    if (fields.length !== 5)
+        return false;
+    const [minute, hour, dom, month, dow] = fields;
+    // Python Monday=0 → cron Sunday=0. Node: getDay() Sunday=0 Monday=1 …
+    // So weekday() + 1 in Python where Monday=0, but Node getDay() already
+    // has Sunday=0. So Node's getDay() IS cron DOW. No conversion needed.
+    const dowVal = dt.getDay();
+    const m = cronFieldMatches(minute, dt.getMinutes());
+    const h = cronFieldMatches(hour, dt.getHours());
+    const monthOk = cronFieldMatches(month, dt.getMonth() + 1); // cron months are 1-based
+    if (!m || !h || !monthOk)
+        return false;
+    const domOk = cronFieldMatches(dom, dt.getDate());
+    const dowOk = cronFieldMatches(dow, dowVal);
+    const domUnconstrained = dom === "*";
+    const dowUnconstrained = dow === "*";
+    if (domUnconstrained && dowUnconstrained)
+        return true;
+    if (domUnconstrained)
+        return dowOk;
+    if (dowUnconstrained)
+        return domOk;
+    return domOk || dowOk; // OR semantics
+}
+// ============ Validation ============
+export function validateCron(cronExpr) {
+    const fields = cronExpr.trim().split(/\s+/);
+    if (fields.length !== 5)
+        return `Cron expression must have 5 fields (min hour dom month dow), got ${fields.length}`;
+    for (const field of fields) {
+        if (!/^[*\d,\-\/]+$/.test(field))
+            return `Invalid cron field: "${field}"`;
+    }
+    // Try matching against a known time to catch structural errors.
+    try {
+        cronMatches(cronExpr, new Date());
+    }
+    catch {
+        return `Could not parse cron expression: "${cronExpr}"`;
+    }
+    return null; // valid
+}
+// ============ Job management ============
+let jobSeq = 0;
+export function scheduleJob(cron, prompt, recurring = true, durable = true) {
+    const err = validateCron(cron);
+    if (err)
+        return { error: err };
+    if (scheduledJobs.size >= MAX_JOBS)
+        return { error: `Too many scheduled jobs (max ${MAX_JOBS}). Cancel one first.` };
+    const id = `cron_${++jobSeq}`;
+    const job = {
+        id,
+        cron: cron.trim(),
+        prompt,
+        recurring,
+        durable,
+        createdAt: Date.now(),
+    };
+    withCronLock(() => {
+        scheduledJobs.set(id, job);
+        if (durable)
+            saveDurableJobs();
+    });
+    return id;
+}
+export function cancelJob(id) {
+    let found = false;
+    withCronLock(() => {
+        found = scheduledJobs.delete(id);
+        lastFired.delete(id);
+        if (found)
+            saveDurableJobs();
+    });
+    return found;
+}
+export function listJobs() {
+    return [...scheduledJobs.values()].sort((a, b) => a.createdAt - b.createdAt);
+}
+// The turn content a fired job injects: the job's own prompt, wrapped with the
+// instruction to DO it now and report the result visibly, then go back to idle.
+// Shared by both consumers — the in-turn one (injectCronMessages in loop.ts, for
+// a job that fires mid-task) and the idle one (the REPL's idle processor, for a
+// job that fires while the user is at the prompt) — so they behave identically.
+export function cronTriggerContent(job) {
+    return [
+        `[Cron job "${job.id}" triggered — ${job.cron}]`,
+        ``,
+        `${job.prompt}`,
+        ``,
+        `Execute this now. When done, report the result directly to the user — make it visible and clear.`,
+        `If the task produces output (e.g. a shell command result, a file change, a value), show it.`,
+        `If there's nothing to show, confirm success with one line.`,
+        ``,
+        `After this, return to idle — do NOT start additional work unless the user asked for a chain of follow-ups.`,
+    ].join("\n");
+}
+// ============ Cron queue ============
+export function hasCronQueue() {
+    return cronQueue.length > 0;
+}
+export function consumeCronQueue() {
+    const fired = [];
+    withCronLock(() => {
+        while (cronQueue.length > 0) {
+            const job = cronQueue.shift();
+            fired.push(job);
+        }
+    });
+    return fired;
+}
+// ============ Durable storage ============
+function durableJobsPath() {
+    return path.resolve(SCHEDULED_TASKS_FILE);
+}
+function saveDurableJobs() {
+    const durable = [...scheduledJobs.values()].filter((j) => j.durable);
+    const payload = { tasks: durable };
+    try {
+        fs.mkdirSync(path.dirname(durableJobsPath()), { recursive: true });
+        fs.writeFileSync(durableJobsPath(), JSON.stringify(payload, null, 2), "utf8");
+    }
+    catch {
+        // Non-fatal: disk writes can fail; the in-memory state is still correct.
+    }
+}
+export function loadDurableJobs() {
+    const p = durableJobsPath();
+    if (!fs.existsSync(p))
+        return;
+    let data;
+    try {
+        data = JSON.parse(fs.readFileSync(p, "utf8"));
+    }
+    catch {
+        return; // corrupt file → ignore (the model can re-schedule)
+    }
+    if (!data.tasks || !Array.isArray(data.tasks))
+        return;
+    for (const raw of data.tasks) {
+        const err = validateCron(raw.cron);
+        if (err)
+            continue; // skip bad expressions so one bad job doesn't block startup
+        const job = {
+            id: raw.id,
+            cron: raw.cron.trim(),
+            prompt: raw.prompt,
+            recurring: raw.recurring ?? true,
+            durable: raw.durable ?? true,
+            createdAt: raw.createdAt || Date.now(),
+        };
+        scheduledJobs.set(job.id, job);
+        // Track the highest seq so new ids don't collide with loaded ones.
+        const match = job.id.match(/^cron_(\d+)$/);
+        if (match)
+            jobSeq = Math.max(jobSeq, parseInt(match[1], 10));
+    }
+}
+// ============ Scheduler loop ============
+let schedulerInterval = null;
+export function startCronScheduler() {
+    if (schedulerInterval)
+        return; // already running
+    schedulerInterval = setInterval(() => {
+        const now = new Date();
+        const minuteMarker = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")} ${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}`;
+        withCronLock(() => {
+            for (const job of [...scheduledJobs.values()]) {
+                try {
+                    if (cronMatches(job.cron, now)) {
+                        if (lastFired.get(job.id) !== minuteMarker) {
+                            cronQueue.push(job);
+                            lastFired.set(job.id, minuteMarker);
+                            if (!job.recurring) {
+                                scheduledJobs.delete(job.id);
+                            }
+                            if (job.durable) {
+                                saveDurableJobs();
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // A single bad job must never kill the scheduler.
+                }
+            }
+        });
+    }, 1000);
+}
+export function stopCronScheduler() {
+    if (schedulerInterval) {
+        clearInterval(schedulerInterval);
+        schedulerInterval = null;
+    }
+}
+// Called by the queue processor — returns true if the agent was idle and we
+// consumed cron items (meaning: the caller should trigger a new turn).
+export function cronItemsPending() {
+    return cronQueue.length > 0;
+}