novahiz 0.3.2 → 0.3.3

package/dist/commands/task.js

@@ -0,0 +1,354 @@
+import { join } from "node:path";
+import { asString, dbPathFor, numberFlag, parse, print, readStdin, splitList } from "./context.js";
+import { loadSpec, NovahizHome } from "../spec.js";
+import { openDb } from "../db.js";
+import { activeTask, addTodos, amendTodo, blockTodo, completeTodo, createTask, dropTask, dropTodo, getTask, getTodo, insertTodo, ledgerSummary, recordTodoDone, reorderTodos, resume, reviewDue, reviewTask, revisionSignals, startTodo } from "../ledger.js";
+const TODO_KINDS = ["read", "edit", "verify", "delegate"];
+export function normalizeTodoInput(item) {
+    const record = (item ?? {});
+    const owners = Array.isArray(record.owner)
+        ? record.owner.map(String)
+        : typeof record.owner === "string"
+            ? record.owner.split(",").map((part) => part.trim()).filter(Boolean)
+            : [];
+    const dependsRaw = record.dependsOn ?? record.depends_on;
+    const dependsOn = Array.isArray(dependsRaw) ? dependsRaw.map(String) : [];
+    const maxIterations = Number(record.maxIterations ?? record.max_iterations);
+    const kind = record.kind ? String(record.kind) : "edit";
+    if (!TODO_KINDS.includes(kind)) {
+        throw new Error(`invalid todo kind: ${kind} (expected one of ${TODO_KINDS.join(", ")})`);
+    }
+    return {
+        label: String(record.label ?? record.title ?? "").trim(),
+        kind: kind,
+        acceptance: record.acceptance ? String(record.acceptance) : undefined,
+        owner: owners.length > 0 ? owners.join(",") : undefined,
+        dependsOn,
+        maxIterations: Number.isFinite(maxIterations) && maxIterations > 0 ? maxIterations : undefined
+    };
+}
+export function commandTask(parsed) {
+    const root = NovahizHome();
+    const spec = loadSpec(root);
+    const action = parsed.positionals[1] ?? "status";
+    const session = asString(parsed.flags.session);
+    const db = openDb(dbPathFor(root, spec));
+    try {
+        if (action === "new")
+            return taskNew(parsed, db, session, spec);
+        if (action === "plan")
+            return taskPlan(parsed, db, session, spec);
+        if (action === "todo")
+            return taskTodo(parsed, db, session, spec);
+        const id = asString(parsed.flags.id) || parsed.positionals[2] || "";
+        // NOTE: review enforcement is asymmetric by design. `start` checks and
+        // blocks if a review is due (prevents starting new work on stale context).
+        // `done` records the completion without requiring a review first — the
+        // review is enforced on the *next* `start` or `review` call. This keeps
+        // the "finish what I'm doing" flow unblocked while still catching stale
+        // context before new work begins.
+        if (action === "start")
+            return taskStart(parsed, db, session, spec);
+        if (action === "done")
+            return taskDone(parsed, db, session, spec);
+        if (action === "block")
+            return taskBlock(parsed, db, session, spec);
+        if (action === "signals")
+            return taskSignals(parsed, db, session, spec);
+        if (action === "review")
+            return taskReview(parsed, db, session, spec);
+        if (action === "amend")
+            return taskAmend(parsed, db, session, spec);
+        if (action === "insert")
+            return taskInsert(parsed, db, session, spec);
+        if (action === "drop")
+            return taskDrop(parsed, db, session, spec);
+        if (action === "reorder")
+            return taskReorder(parsed, db, session, spec);
+        if (action === "read")
+            return taskRead(parsed, db, session, spec);
+        if (action === "status")
+            return taskRead(parsed, db, session, spec);
+        if (action === "resume")
+            return taskResume(db, session);
+        if (action === "current")
+            return taskCurrent(db, session);
+        print({ error: `unknown task action: ${action}`, actions: ["new", "plan", "todo", "start", "done", "block", "review", "amend", "insert", "drop", "reorder", "signals", "status", "resume", "current"] });
+        process.exitCode = 1;
+    }
+    catch (error) {
+        print({ error: String(error?.message ?? error) });
+        process.exitCode = 1;
+    }
+    finally {
+        db.close();
+    }
+}
+function taskRead(parsed, db, session, spec) {
+    const state = resume(db, session || undefined);
+    const summary = ledgerSummary(state);
+    let review = null;
+    const signals = state.task ? revisionSignals(db, state.task.id) : [];
+    if (state.task && spec.config.ledger?.enabled !== false) {
+        review = reviewDue(db, state.task.id, spec.config.ledger.review);
+        summary.push(`  review: ${review.due ? "DUE" : "ok"} (edits ${review.edits}/${review.policy.edits}, todos ${review.todos}/${review.policy.todos})`);
+        if (review.due)
+            summary.push(`  -> reconcile with: novahiz task review --task ${state.task.id} --reason "<what changed>"`);
+        for (const signal of signals)
+            summary.push(`  signal ${signal.type}: ${signal.detail}`);
+    }
+    print({ ...state, summary, review, signals });
+}
+function taskResume(db, session) {
+    const state = resume(db, session || undefined);
+    const summary = ledgerSummary(state);
+    const next = state.todos.find((todo) => todo.status === "pending");
+    print({
+        ...state,
+        summary,
+        next: next ? { id: next.id, seq: next.seq, label: next.label, kind: next.kind } : null
+    });
+}
+function taskCurrent(db, session) {
+    const state = resume(db, session || undefined);
+    print({ task: state.task, current: state.current, todos: state.todos.length });
+}
+function taskReorder(parsed, db, session, spec) {
+    const taskId = asString(parsed.flags.task) || activeTask(db, session || undefined)?.id;
+    if (!taskId) {
+        print({ error: "task reorder requires --task or an active task" });
+        process.exitCode = 1;
+        return;
+    }
+    const requested = splitList(parsed.flags.order);
+    const order = requested.length > 0 ? requested : parsed.positionals.slice(2);
+    print({ task: getTask(db, taskId), todos: reorderTodos(db, taskId, order) });
+    return;
+}
+function taskDrop(parsed, db, session, spec) {
+    const id = asString(parsed.flags.id) || parsed.positionals[2] || "";
+    if (!id) {
+        print({
+            error: "task drop requires --id",
+            usage: "novahiz task drop --id <task_id|todo_id> --reason \"why\""
+        });
+        process.exitCode = 1;
+        return;
+    }
+    const reason = asString(parsed.flags.reason);
+    if (getTask(db, id)) {
+        print({ task: dropTask(db, id, reason) });
+        return;
+    }
+    if (getTodo(db, id)) {
+        print({ todo: dropTodo(db, id, reason) });
+        return;
+    }
+    print({
+        error: `unknown id: ${id}`,
+        hint: "expected a task id or a todo id (pass --reason to abandon an active task)"
+    });
+    process.exitCode = 1;
+}
+function taskInsert(parsed, db, session, spec) {
+    const taskId = asString(parsed.flags.task) || activeTask(db, session || undefined)?.id;
+    if (!taskId) {
+        print({ error: "task insert requires --task or an active task" });
+        process.exitCode = 1;
+        return;
+    }
+    const label = (asString(parsed.flags.label) || parsed.positionals.slice(2).join(" ")).trim();
+    if (!label) {
+        print({ error: "task insert requires --label" });
+        process.exitCode = 1;
+        return;
+    }
+    const item = normalizeTodoInput({
+        label,
+        kind: asString(parsed.flags.kind) || "edit",
+        acceptance: asString(parsed.flags.acceptance) || undefined,
+        owner: splitList(parsed.flags.owner),
+        maxIterations: numberFlag(parsed, "max-iterations", { min: 1, integer: true }) || undefined
+    });
+    const positionRaw = asString(parsed.flags.position);
+    const position = positionRaw === "" ? "end" : /^\d+$/.test(positionRaw) ? Number(positionRaw) : positionRaw;
+    print({ todo: insertTodo(db, taskId, item, position), task: getTask(db, taskId) });
+    return;
+}
+function taskAmend(parsed, db, session, spec) {
+    const id = asString(parsed.flags.id) || parsed.positionals[2] || "";
+    if (!id) {
+        print({ error: "task amend requires --id" });
+        process.exitCode = 1;
+        return;
+    }
+    const patch = {};
+    const label = asString(parsed.flags.label);
+    if (label)
+        patch.label = label;
+    const kind = asString(parsed.flags.kind);
+    if (kind && !TODO_KINDS.includes(kind)) {
+        print({ error: `invalid todo kind: ${kind} (expected one of ${TODO_KINDS.join(", ")})` });
+        process.exitCode = 1;
+        return;
+    }
+    if (kind)
+        patch.kind = kind;
+    if (parsed.flags.acceptance !== undefined)
+        patch.acceptance = asString(parsed.flags.acceptance);
+    const owners = splitList(parsed.flags.owner);
+    if (owners.length > 0)
+        patch.owner = owners.join(",");
+    const maxIterations = numberFlag(parsed, "max-iterations", { min: 1, integer: true });
+    if (maxIterations !== undefined && maxIterations > 0)
+        patch.maxIterations = maxIterations;
+    print({ todo: amendTodo(db, id, patch) });
+    return;
+}
+function taskReview(parsed, db, session, spec) {
+    const taskId = asString(parsed.flags.task) || activeTask(db, session || undefined)?.id;
+    if (!taskId) {
+        print({ error: "task review requires --task or an active task" });
+        process.exitCode = 1;
+        return;
+    }
+    const raw = (asString(parsed.flags.json) || readStdin()).trim();
+    let diff = {};
+    if (raw.length > 0) {
+        try {
+            diff = JSON.parse(raw);
+        }
+        catch {
+            print({ error: "invalid JSON review diff" });
+            process.exitCode = 1;
+            return;
+        }
+    }
+    const outcome = reviewTask(db, { taskId, ...diff });
+    print({ ...outcome, reason: asString(parsed.flags.reason) });
+    return;
+}
+function taskSignals(parsed, db, session, spec) {
+    const taskId = asString(parsed.flags.task) || activeTask(db, session || undefined)?.id;
+    if (!taskId) {
+        print({ error: "task signals requires --task or an active task" });
+        process.exitCode = 1;
+        return;
+    }
+    print({ task: getTask(db, taskId), signals: revisionSignals(db, taskId) });
+    return;
+}
+function taskBlock(parsed, db, session, spec) {
+    const id = asString(parsed.flags.id) || parsed.positionals[2] || "";
+    if (!id) {
+        print({ error: "task block requires --id" });
+        process.exitCode = 1;
+        return;
+    }
+    print({ todo: blockTodo(db, id, asString(parsed.flags.reason)) });
+    return;
+}
+function taskDone(parsed, db, session, spec) {
+    const id = asString(parsed.flags.id) || parsed.positionals[2] || "";
+    if (!id) {
+        print({ error: "task done requires --id" });
+        process.exitCode = 1;
+        return;
+    }
+    const todo = completeTodo(db, id, asString(parsed.flags.proof));
+    if (spec.config.ledger?.enabled !== false)
+        recordTodoDone(db, todo.task_id);
+    print({ todo });
+    return;
+}
+function taskStart(parsed, db, session, spec) {
+    const id = asString(parsed.flags.id) || parsed.positionals[2] || "";
+    if (!id) {
+        print({ error: "task start requires --id" });
+        process.exitCode = 1;
+        return;
+    }
+    const target = getTodo(db, id);
+    if (target && spec.config.ledger?.enabled !== false) {
+        const due = reviewDue(db, target.task_id, spec.config.ledger.review);
+        if (due.due) {
+            print({ error: due.reason, task: target.task_id });
+            process.exitCode = 1;
+            return;
+        }
+    }
+    print({ todo: startTodo(db, id) });
+    return;
+}
+function taskTodo(parsed, db, session, spec) {
+    const id = asString(parsed.flags.id) || parsed.positionals[2] || "";
+    const taskId = asString(parsed.flags.task) || activeTask(db, session || undefined)?.id;
+    if (!taskId) {
+        print({ error: "task todo requires --task or an active task" });
+        process.exitCode = 1;
+        return;
+    }
+    const label = (asString(parsed.flags.label) || parsed.positionals.slice(2).join(" ")).trim();
+    if (label.length === 0) {
+        print({ error: "task todo requires --label" });
+        process.exitCode = 1;
+        return;
+    }
+    const maxIterations = numberFlag(parsed, "max-iterations", { min: 1, integer: true });
+    const owners = splitList(parsed.flags.owner);
+    const todos = addTodos(db, taskId, [
+        {
+            label,
+            kind: (asString(parsed.flags.kind) || "edit"),
+            acceptance: asString(parsed.flags.acceptance) || undefined,
+            owner: owners.length > 0 ? owners.join(",") : undefined,
+            maxIterations: maxIterations !== undefined && maxIterations > 0 ? maxIterations : undefined
+        }
+    ]);
+    print({ task: getTask(db, taskId), todos });
+    return;
+}
+function taskPlan(parsed, db, session, spec) {
+    const id = asString(parsed.flags.id) || parsed.positionals[2] || "";
+    const taskId = asString(parsed.flags.task) || activeTask(db, session || undefined)?.id;
+    if (!taskId) {
+        print({ error: "task plan requires --task or an active task" });
+        process.exitCode = 1;
+        return;
+    }
+    const raw = (asString(parsed.flags.json) || readStdin()).trim();
+    if (raw.length === 0 && parsed.flags.json === undefined) {
+        print({ error: "task plan requires --json <array> or JSON on stdin" });
+        process.exitCode = 1;
+        return;
+    }
+    let parsedItems;
+    try {
+        parsedItems = JSON.parse(raw.length > 0 ? raw : "[]");
+    }
+    catch {
+        print({ error: "invalid JSON plan" });
+        process.exitCode = 1;
+        return;
+    }
+    if (!Array.isArray(parsedItems)) {
+        print({ error: "plan must be a JSON array of todos" });
+        process.exitCode = 1;
+        return;
+    }
+    const todos = addTodos(db, taskId, parsedItems.map(normalizeTodoInput));
+    print({ task: getTask(db, taskId), todos });
+    return;
+}
+function taskNew(parsed, db, session, spec) {
+    const title = (asString(parsed.flags.title) || parsed.positionals.slice(2).join(" ")).trim();
+    if (title.length === 0) {
+        print({ error: "task new requires --title" });
+        process.exitCode = 1;
+        return;
+    }
+    const id = asString(parsed.flags.id) || undefined;
+    const task = createTask(db, { title, id, sessionId: session || undefined });
+    print({ task, todos: [] });
+    return;
+}

package/dist/commands/tokens.js

@@ -0,0 +1,69 @@
+import { dbPathFor, emit, flagOn } from "./context.js";
+import { loadSpec, NovahizHome } from "../spec.js";
+import { openDb } from "../db.js";
+import * as ui from "../render.js";
+const AVG_LINE_BYTES = 80;
+const AVG_TOKENS_PER_LINE = 25;
+export function commandTokens(parsed) {
+    const root = NovahizHome();
+    const spec = loadSpec(root);
+    const db = openDb(dbPathFor(root, spec));
+    const enforcementEvents = db.prepare("SELECT COUNT(*) AS n FROM enforcement_log").get().n;
+    const invocationEvents = db.prepare("SELECT COUNT(*) AS n FROM skill_invocations").get().n;
+    const roadmapEvents = db.prepare("SELECT COUNT(*) AS n FROM roadmap_progress").get().n;
+    const taskEvents = db.prepare("SELECT COUNT(*) AS n FROM tasks").get().n;
+    const todoEvents = db.prepare("SELECT COUNT(*) AS n FROM todos").get().n;
+    const blocked = db.prepare("SELECT COUNT(*) AS n FROM enforcement_log WHERE decision = 'block'").get().n;
+    const blockedBytes = blocked * AVG_LINE_BYTES;
+    const blockedTokens = Math.round((blocked * AVG_LINE_BYTES) / AVG_TOKENS_PER_LINE);
+    const byTool = db.prepare("SELECT tool, COUNT(*) AS n FROM enforcement_log GROUP BY tool ORDER BY n DESC").all();
+    const byDecision = db.prepare("SELECT decision, COUNT(*) AS n FROM enforcement_log GROUP BY decision ORDER BY n DESC").all();
+    db.close();
+    const events = enforcementEvents + invocationEvents + roadmapEvents + taskEvents + todoEvents;
+    const value = {
+        events,
+        enforcement: enforcementEvents,
+        invocations: invocationEvents,
+        roadmap: roadmapEvents,
+        tasks: taskEvents,
+        todos: todoEvents,
+        blocked,
+        estimatedBytesSaved: blockedBytes,
+        estimatedTokensSaved: blockedTokens,
+        byTool,
+        byDecision
+    };
+    const calibrate = flagOn(parsed, "calibrate");
+    emit(parsed, value, () => {
+        const lines = [
+            ui.heading("novahiz tokens"),
+            "",
+            ui.kv([
+                ["events:", String(events)],
+                ["enforcement:", String(enforcementEvents)],
+                ["invocations:", String(invocationEvents)],
+                ["roadmap:", String(roadmapEvents)],
+                ["tasks:", String(taskEvents)],
+                ["todos:", String(todoEvents)],
+                ["blocked:", String(blocked)],
+                ["est. bytes saved (~±5x):", ui.bytes(blockedBytes)],
+                ["est. tokens saved (~±5x):", String(blockedTokens)]
+            ]),
+            "",
+            ui.heading("By tool"),
+            ui.table(["tool", "n"], byTool.map((row) => [row.tool, String(row.n)])),
+            "",
+            ui.heading("By decision"),
+            ui.table(["decision", "n"], byDecision.map((row) => [row.decision, String(row.n)]))
+        ];
+        if (calibrate) {
+            const bytesPerToken = AVG_LINE_BYTES / AVG_TOKENS_PER_LINE;
+            lines.push("", ui.heading("Calibration"), ui.kv([
+                ["avg line bytes:", String(AVG_LINE_BYTES)],
+                ["avg tokens/line:", String(AVG_TOKENS_PER_LINE)],
+                ["bytes/token:", bytesPerToken.toFixed(1)]
+            ]));
+        }
+        return lines.join("\n");
+    });
+}