@netnodeag/kraftwerk 0.18.0 → 0.19.0

package/dist/cli/kraftwerk.js

@@ -12,6 +12,7 @@ import { renderCreateBrief } from "./create-brief.js";
 import { runDoctor } from "./doctor.js";
 import { runInit } from "./init.js";
 import { registerKnowledgeCommands } from "./knowledge.js";
+import { registerRoutineCommands } from "./routines.js";
 import { listRuns, showRun } from "./runs.js";
 import { runUi } from "./ui.js";
 /**
@@ -22,6 +23,7 @@ import { runUi } from "./ui.js";
  *   kraftwerk run [workflow] [text]   run one (prompts interactively if omitted)
  *   kraftwerk runs [show <id>]        inspect past runs from their traces
  *   kraftwerk knowledge ...           Context & Knowledge: OKF bundles (list/get/put/verify/...)
+ *   kraftwerk routines ...            per-agent scheduled prompts (list/add/remove/enable/run)
  *   kraftwerk ui                      start the inspector web UI (localhost:1981)
  *   kraftwerk doctor                  preflight: harness CLIs, docker, workflows, env
  *   kraftwerk validate [paths...]     validate without executing
@@ -253,6 +255,7 @@ runs
     await showRun(process.cwd(), runId, opts);
 });
 registerKnowledgeCommands(program);
+registerRoutineCommands(program);
 program
     .command("ui")
     .description("Start the inspector web UI for this project's runs and workflows")

package/dist/cli/routines.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerRoutineCommands(program: Command): void;

package/dist/cli/routines.js

@@ -0,0 +1,177 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import chalk from "chalk";
+import { resolveProject } from "../config.js";
+import { setOutputDir, setProjectRoot } from "../inspector/context.js";
+import { deleteRoutine, listRoutines, routineStatuses, saveRoutine, } from "../inspector/routines.js";
+import { getMember, listMembers } from "../inspector/team.js";
+/**
+ * `kraftwerk routines` — CLI surface over per-agent scheduled prompts
+ * (agents/<slug>/routines.yml). Definition CRUD works directly on the
+ * files; `run` fires through the running inspector server, because the
+ * session (chat) and the scheduler live there.
+ */
+/** Point the inspector context at this project so team/routine paths resolve. */
+async function initContext() {
+    const project = await resolveProject(process.cwd());
+    setProjectRoot(project.root);
+    setOutputDir(project.outputDir);
+    return { port: project.config.port ?? 1981 };
+}
+async function requireMember(slug) {
+    if (!(await getMember(slug))) {
+        console.error(chalk.red(`Agent "${slug}" not found (expected agents/${slug}/agent.yml).`));
+        process.exit(2);
+    }
+}
+async function readStdin() {
+    let data = "";
+    for await (const chunk of process.stdin)
+        data += chunk;
+    return data;
+}
+/** ISO timestamp → local "YYYY-MM-DD HH:mm" (schedules are server-local time). */
+const fmtTime = (iso) => {
+    if (!iso)
+        return "—";
+    const d = new Date(iso);
+    const p = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
+};
+function routineLine(r) {
+    const state = r.enabled ? chalk.green("on ") : chalk.dim("off");
+    const flags = r.lastError ? ` ${chalk.red(`error: ${r.lastError}`)}` : "";
+    return (`  ${chalk.cyan(r.id.padEnd(24))} ${state} ${r.schedule.padEnd(14)} ` +
+        chalk.dim(`next ${fmtTime(r.nextRunAt).padEnd(17)} last ${fmtTime(r.lastRunAt)}`) +
+        flags);
+}
+export function registerRoutineCommands(program) {
+    const routines = program
+        .command("routines")
+        .description("Per-agent scheduled prompts (agents/<slug>/routines.yml): list, add, run, ...");
+    routines
+        .command("list", { isDefault: true })
+        .description("List routines — all agents, or one agent with schedule state")
+        .argument("[agent]", "Agent slug (folder under agents/)")
+        .option("--json", "Machine-readable output")
+        .action(async (agent, opts) => {
+        await initContext();
+        const slugs = agent ? [agent] : (await listMembers()).map((m) => m.slug);
+        if (agent)
+            await requireMember(agent);
+        const all = {};
+        for (const slug of slugs)
+            all[slug] = await routineStatuses(slug);
+        if (opts.json)
+            return void console.log(JSON.stringify(all, null, 2));
+        let any = false;
+        for (const [slug, rs] of Object.entries(all)) {
+            if (rs.length === 0)
+                continue;
+            any = true;
+            console.log(chalk.bold(slug));
+            for (const r of rs)
+                console.log(routineLine(r));
+        }
+        if (!any) {
+            console.log(chalk.yellow("No routines yet — add one with `kraftwerk routines add <agent> --name ... --schedule ... --prompt ...`."));
+        }
+    });
+    routines
+        .command("add")
+        .description("Create or update a routine (same id = update)")
+        .argument("<agent>", "Agent slug")
+        .requiredOption("--name <name>", 'Display name, e.g. "Morning triage"')
+        .requiredOption("--schedule <cron>", '5-field cron ("0 9 * * 1-5") or @hourly/@daily/@weekly/@monthly')
+        .option("--prompt <text>", "The prompt to post (or pipe it on stdin / use --file)")
+        .option("--file <path>", "Read the prompt from a file")
+        .option("--id <id>", "Routine id (default: derived from the name)")
+        .option("--disabled", "Create it switched off")
+        .action(async (agent, opts) => {
+        await initContext();
+        await requireMember(agent);
+        const prompt = opts.prompt ??
+            (opts.file ? await readFile(path.resolve(opts.file), "utf8") : process.stdin.isTTY ? "" : await readStdin());
+        if (!prompt.trim()) {
+            console.error(chalk.red("No prompt (--prompt, --file, or pipe it on stdin)."));
+            process.exit(2);
+        }
+        try {
+            const existing = new Set((await listRoutines(agent)).map((r) => r.id));
+            const routine = await saveRoutine(agent, {
+                ...(opts.id ? { id: opts.id } : {}),
+                name: opts.name,
+                schedule: opts.schedule,
+                prompt,
+                enabled: !opts.disabled,
+            });
+            const verb = existing.has(routine.id) ? "updated" : "created";
+            console.log(`${chalk.green("✔")} ${verb} ${chalk.cyan(`${agent}/${routine.id}`)} ` +
+                chalk.dim(`(${routine.schedule}${routine.enabled ? "" : ", disabled"})`));
+            if (routine.enabled) {
+                console.log(chalk.dim("  fires from the inspector server — make sure `kraftwerk ui` is running."));
+            }
+        }
+        catch (err) {
+            console.error(chalk.red(err.message));
+            process.exit(2);
+        }
+    });
+    routines
+        .command("remove")
+        .description("Delete a routine")
+        .argument("<agent>", "Agent slug")
+        .argument("<id>", "Routine id (see `kraftwerk routines <agent>`)")
+        .action(async (agent, id) => {
+        await initContext();
+        await requireMember(agent);
+        if (!(await listRoutines(agent)).some((r) => r.id === id)) {
+            console.error(chalk.red(`Routine "${agent}/${id}" not found.`));
+            process.exit(2);
+        }
+        await deleteRoutine(agent, id);
+        console.log(`${chalk.green("✔")} removed ${chalk.cyan(`${agent}/${id}`)}`);
+    });
+    for (const [verb, enabled] of [["enable", true], ["disable", false]]) {
+        routines
+            .command(verb)
+            .description(`${verb === "enable" ? "Enable" : "Disable"} a routine`)
+            .argument("<agent>", "Agent slug")
+            .argument("<id>", "Routine id")
+            .action(async (agent, id) => {
+            await initContext();
+            const routine = (await listRoutines(agent)).find((r) => r.id === id);
+            if (!routine) {
+                console.error(chalk.red(`Routine "${agent}/${id}" not found.`));
+                process.exit(2);
+            }
+            await saveRoutine(agent, { ...routine, enabled });
+            console.log(`${chalk.green("✔")} ${chalk.cyan(`${agent}/${id}`)} ${verb}d`);
+        });
+    }
+    routines
+        .command("run")
+        .description("Fire a routine now (opens a session via the running `kraftwerk ui` server)")
+        .argument("<agent>", "Agent slug")
+        .argument("<id>", "Routine id")
+        .option("--port <port>", "Inspector port (default: kraftwerk.yml `port`, else 1981)")
+        .action(async (agent, id, opts) => {
+        const { port } = await initContext();
+        const p = opts.port ? Number(opts.port) : port;
+        const url = `http://localhost:${p}/api/team/${encodeURIComponent(agent)}/routines/${encodeURIComponent(id)}/run`;
+        let body;
+        try {
+            body = (await (await fetch(url, { method: "POST" })).json());
+        }
+        catch {
+            console.error(chalk.red(`Inspector not reachable on localhost:${p} — routines fire through the server; start it with \`kraftwerk ui\`.`));
+            process.exit(2);
+        }
+        if (body.error || !body.chatId) {
+            console.error(chalk.red(body.error ?? "run failed"));
+            process.exit(2);
+        }
+        console.log(`${chalk.green("✔")} ${chalk.cyan(`${agent}/${id}`)} fired → session ${body.chatId}\n` +
+            chalk.dim(`  http://localhost:${p}/#/agents/${encodeURIComponent(agent)}/chat/${body.chatId}`));
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netnodeag/kraftwerk",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "description": "Deterministic workflow-as-code framework: agents (persona + model + tools + harness) run in bounded phases on headless CLI harnesses (claude -p, codex exec, pi); code owns the control flow, envelopes + gates judge the results",
   "keywords": [
     "agents",