novahiz 0.3.2 → 0.3.4

package/dist/cli.js

@@ -0,0 +1,218 @@
+import { readFileSync, existsSync } from "node:fs";
+import { join, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+import { parse, print, flagOn } from "./commands/context.js";
+import { expandHome } from "./spec.js";
+import { commandCheck, commandSync, commandClassify, commandSkills, commandCategories, commandRules, commandSessionLoad, commandSessionState, commandCatalog, commandRoadmap, commandStep, commandProviders, commandDeps, commandDispatch } from "./commands/inspect.js";
+import { commandGate } from "./commands/gate.js";
+import { commandReport } from "./commands/report.js";
+import { commandTask } from "./commands/task.js";
+import { commandClean } from "./commands/clean.js";
+import { commandDoctor } from "./commands/doctor.js";
+import { commandTokens } from "./commands/tokens.js";
+import { graftCommand } from "./commands/graft.js";
+import { commandInit } from "./commands/init.js";
+import { commandAutodocs } from "./commands/autodocs.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// M6: HOME was a module-level const, so `--home` (which sets the env var in
+// main()) was silently ignored by the current execution. Read it lazily.
+function homeDir() {
+    return (process.env.NOVAHIZ_HOME ||
+        join(process.env.HOME || process.env.USERPROFILE || "", ".config", "novahiz"));
+}
+function runSync() {
+    const home = homeDir();
+    const cli = join(home, "src", "cli.ts");
+    if (existsSync(cli)) {
+        spawnSync(process.execPath, [cli, "sync"], {
+            encoding: "utf8",
+            stdio: "inherit",
+            env: { ...process.env, NOVAHIZ_HOME: home }
+        });
+    }
+}
+function usage() {
+    print({
+        name: "novahiz",
+        commands: [
+            "init                    Initialize Novahiz in the current project",
+            "setup                   Install Novahiz (config, skills, catalog)",
+            "autodocs [--flush]      Sync docs and memory after major project changes",
+            "doctor                  Check that everything works",
+            "status                  Show current classification and gate state",
+            "task new <title>        Start a new tracked task",
+            "task status             Show task progress",
+            "task done <id>          Mark a todo as complete",
+            "report                  Session report",
+            "clean                   Remove old logs and sessions",
+            "graft                   Version-control the ledger (graft init/log/diff/status/restore)",
+            "upgrade                 Pull latest and rebuild catalog",
+            "version                 Show version",
+            "",
+            "",
+            "Options:",
+            "  --home <path>         Override Novahiz home directory",
+            "  --version, -v         Show version",
+            "  --help, -h            Show this help",
+            "",
+            "Advanced (for power users and adapters):",
+            "  classify <text>       Classify a prompt",
+            "  gate --tool <t> --file <f>  Check if an edit is allowed",
+            "  skills [--category c] List loaded skills",
+            "  catalog <query>       Search the skill catalog",
+            "  roadmap --category c  Show execution roadmap",
+            "  dispatch [--task id]  Generate work packets",
+            "  tokens                Token diagnostics",
+        ]
+    });
+}
+function printVersion() {
+    try {
+        const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf8"));
+        process.stdout.write(`Novahiz ${pkg.version}\n`);
+    }
+    catch {
+        process.stdout.write("Novahiz (unknown version)\n");
+    }
+}
+function runInit() {
+    const home = homeDir();
+    const installScript = join(home, "install", "install.mjs");
+    if (existsSync(installScript)) {
+        process.stdout.write("Installing Novahiz...\n");
+        const result = spawnSync(process.execPath, [installScript, "--yes"], {
+            encoding: "utf8",
+            stdio: "inherit",
+            env: { ...process.env, NOVAHIZ_HOME: home }
+        });
+        if (result.status !== 0) {
+            process.stderr.write("Installation failed. Run `novahiz doctor` for details.\n");
+            process.exitCode = 1;
+            return;
+        }
+    }
+    process.stdout.write("\nBuilding skill catalog...\n");
+    runSync();
+    process.stdout.write("\nDone! Restart opencode to activate Novahiz.\n");
+}
+function runUpgrade(parsed) {
+    const home = homeDir();
+    if (!existsSync(join(home, ".git"))) {
+        process.stderr.write("Not a git repository. Install from source first.\n");
+        process.exitCode = 1;
+        return;
+    }
+    // P2-C (LOW): `git pull` rewrote the running code (hooks included) with no
+    // preview. Default to a dry run; `--apply` is required to actually pull.
+    if (!flagOn(parsed, "apply")) {
+        const dry = spawnSync("git", ["pull", "--dry-run"], { cwd: home, encoding: "utf8" });
+        const preview = `${dry.stdout ?? ""}${dry.stderr ?? ""}`.trim();
+        if (preview)
+            process.stdout.write(preview + "\n");
+        if (dry.status !== 0) {
+            process.stderr.write("Dry run failed; fix git first.\n");
+            process.exitCode = 1;
+            return;
+        }
+        process.stdout.write("Dry run only. Re-run `novahiz upgrade --apply` to pull and rebuild.\n");
+        process.exitCode = 1;
+        return;
+    }
+    process.stdout.write("Pulling latest changes...\n");
+    const pull = spawnSync("git", ["pull", "--ff-only"], { cwd: home, stdio: "inherit" });
+    if (pull.status !== 0) {
+        process.stderr.write("Pull failed; nothing rebuilt.\n");
+        process.exitCode = 1;
+        return;
+    }
+    process.stdout.write("\nRebuilding skill catalog...\n");
+    runSync();
+    process.stdout.write("\nUpgraded! Restart opencode to apply changes.\n");
+}
+function main(argv) {
+    const parsed = parse(argv);
+    if (typeof parsed.flags.home === "string" && parsed.flags.home.length > 0) {
+        process.env.NOVAHIZ_HOME = resolve(expandHome(parsed.flags.home));
+    }
+    const command = parsed.positionals[0];
+    if (command === undefined || command === "help" || command === "--help" || command === "-h") {
+        usage();
+        return;
+    }
+    if (parsed.flags.version || parsed.flags.v) {
+        printVersion();
+        return;
+    }
+    switch (command) {
+        case "init":
+            return commandInit(parsed);
+        case "setup":
+            return runInit();
+        case "autodocs":
+            return commandAutodocs(parsed);
+        case "doctor":
+            return commandDoctor(parsed);
+        case "status":
+        case "check":
+            return commandCheck();
+        case "report":
+            return commandReport(parsed);
+        case "clean":
+            return commandClean(parsed);
+        case "upgrade":
+        case "update":
+            return runUpgrade(parsed);
+        case "version":
+        case "-v":
+        case "--version":
+            return printVersion();
+        case "task":
+            return commandTask(parsed);
+        case "sync":
+            return commandSync();
+        case "classify":
+            return commandClassify(parsed);
+        case "gate":
+            return commandGate(parsed);
+        case "skills":
+            return commandSkills(parsed);
+        case "categories":
+            return commandCategories();
+        case "rules":
+            return commandRules();
+        case "session-load":
+            return commandSessionLoad(parsed);
+        case "session-state":
+            return commandSessionState(parsed);
+        case "catalog":
+            return commandCatalog(parsed);
+        case "roadmap":
+            return commandRoadmap(parsed);
+        case "step":
+            return commandStep(parsed);
+        case "providers":
+            return commandProviders(parsed);
+        case "deps":
+            return commandDeps(parsed);
+        case "dispatch":
+            return commandDispatch(parsed);
+        case "tokens":
+            return commandTokens(parsed);
+        case "graft":
+            return graftCommand(parsed.positionals.slice(1));
+        default:
+            process.stderr.write(`novahiz: unknown command "${command}"\n\n`);
+            usage();
+            process.exitCode = 1;
+            return;
+    }
+}
+try {
+    main(process.argv.slice(2));
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`novahiz: ${message}\n`);
+    process.exitCode = 1;
+}

package/dist/commands/autodocs.js

@@ -0,0 +1,218 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { autoDocsEnabled, clearDirty, dateStamp, isMajorPath, markDirty, readProjectConfig, readState, upsertChangesSection, writeProjectConfig } from "../autodocs.js";
+import { emit, flagOn } from "./context.js";
+import { memoryRoot, writeEntry } from "../memory.js";
+import * as ui from "../render.js";
+const MAX_DOC_PATHS = 12;
+const ARCHITECTURE = "novahiz-docs/ARCHITECTURE.md";
+export function ensureProjectAutoDocsConfig(cwd) {
+    try {
+        const config = readProjectConfig(cwd);
+        if (config.autoDocs === true)
+            return "existing";
+        writeProjectConfig(cwd, { ...config, autoDocs: true });
+        return "created";
+    }
+    catch {
+        return "failed";
+    }
+}
+function skipResult(reason, paths = []) {
+    const state = readState(process.cwd());
+    return {
+        status: "skipped",
+        reason,
+        docsPath: null,
+        docsUpdated: false,
+        memorySlot: null,
+        paths,
+        pending: state.pending.length,
+        lastSync: state.lastSync
+    };
+}
+function flushDocs(cwd, paths) {
+    const docPath = join(cwd, "novahiz-docs", "ARCHITECTURE.md");
+    if (!existsSync(docPath))
+        return { path: ARCHITECTURE, updated: false };
+    const sample = paths.slice(0, MAX_DOC_PATHS);
+    if (sample.length === 0)
+        return { path: ARCHITECTURE, updated: false };
+    const doc = readFileSync(docPath, "utf8");
+    const lines = sample.map((path) => `${path} (${dateStamp()})`);
+    const next = upsertChangesSection(doc, lines);
+    if (next === doc)
+        return { path: ARCHITECTURE, updated: false };
+    writeFileSync(docPath, next, "utf8");
+    return { path: ARCHITECTURE, updated: true };
+}
+function flushMemory(cwd, paths) {
+    const sample = paths.slice(0, MAX_DOC_PATHS);
+    if (sample.length === 0)
+        return null;
+    try {
+        const result = writeEntry({
+            title: "Auto docs sync",
+            description: "Change log written by novahiz autodocs",
+            tags: ["autodocs", "sync"],
+            root: memoryRoot(cwd),
+            content: [`Sync: ${new Date().toISOString()}`, ...sample.map((path) => `- ${path}`)].join("\n")
+        });
+        return result.slot.id;
+    }
+    catch {
+        return null;
+    }
+}
+export function flushAutoDocs(cwd) {
+    if (!autoDocsEnabled(cwd)) {
+        return skipResult("autoDocs disabled (set autoDocs=true in .novahiz/config.json or unset NOVAHIZ_AUTODOCS)");
+    }
+    const state = readState(cwd);
+    if (!state.dirty && state.pending.length === 0) {
+        return skipResult("nothing dirty", state.pending);
+    }
+    try {
+        const paths = state.pending;
+        const docs = flushDocs(cwd, paths);
+        const memorySlot = flushMemory(cwd, paths);
+        const next = clearDirty(cwd);
+        return {
+            status: "flushed",
+            reason: `${paths.length} path(s) recorded`,
+            docsPath: docs.path,
+            docsUpdated: docs.updated,
+            memorySlot,
+            paths,
+            pending: next.pending.length,
+            lastSync: next.lastSync
+        };
+    }
+    catch (error) {
+        return {
+            status: "failed",
+            reason: error.message,
+            docsPath: null,
+            docsUpdated: false,
+            memorySlot: null,
+            paths: state.pending,
+            pending: state.pending.length,
+            lastSync: state.lastSync
+        };
+    }
+}
+function markFromArgs(cwd, mark, positionals) {
+    const raw = typeof mark === "string" && mark.length > 0
+        ? mark
+        : positionals.join(",");
+    const list = raw
+        .split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+    if (list.length === 0) {
+        return {
+            status: "failed",
+            reason: "--mark needs at least one path",
+            docsPath: null,
+            docsUpdated: false,
+            memorySlot: null,
+            paths: [],
+            pending: readState(cwd).pending.length,
+            lastSync: readState(cwd).lastSync
+        };
+    }
+    const accepted = [];
+    const rejected = [];
+    for (const path of list) {
+        if (isMajorPath(path)) {
+            markDirty(cwd, path);
+            accepted.push(path);
+        }
+        else {
+            rejected.push(path);
+        }
+    }
+    const state = readState(cwd);
+    if (accepted.length === 0) {
+        return {
+            status: "skipped",
+            reason: `no major path among ${rejected.join(", ")}`,
+            docsPath: null,
+            docsUpdated: false,
+            memorySlot: null,
+            paths: rejected,
+            pending: state.pending.length,
+            lastSync: state.lastSync
+        };
+    }
+    return {
+        status: "marked",
+        reason: rejected.length > 0
+            ? `marked ${accepted.length}, ignored ${rejected.length} non-major`
+            : `marked ${accepted.length}`,
+        docsPath: null,
+        docsUpdated: false,
+        memorySlot: null,
+        paths: accepted,
+        pending: state.pending.length,
+        lastSync: state.lastSync
+    };
+}
+function statusView(cwd) {
+    const config = readProjectConfig(cwd);
+    const state = readState(cwd);
+    return {
+        cwd,
+        autoDocs: config.autoDocs === true,
+        enabled: autoDocsEnabled(cwd),
+        dirty: state.dirty,
+        pending: state.pending,
+        lastSync: state.lastSync,
+        sessions: state.sessions
+    };
+}
+export function commandAutodocs(parsed) {
+    const cwd = process.cwd();
+    const wantFlush = flagOn(parsed, "flush");
+    const markFlag = parsed.flags.mark;
+    const isMark = markFlag !== undefined && markFlag !== false;
+    let outcome = null;
+    if (isMark) {
+        outcome = markFromArgs(cwd, markFlag, parsed.positionals.slice(1));
+    }
+    else if (wantFlush) {
+        outcome = flushAutoDocs(cwd);
+    }
+    const value = outcome
+        ? { ...statusView(cwd), action: isMark ? "mark" : "flush", ...outcome }
+        : { ...statusView(cwd), action: "status" };
+    emit(parsed, value, () => {
+        const view = statusView(cwd);
+        const lines = [
+            ui.heading("novahiz autodocs"),
+            ui.kv([
+                ["Cwd", String(view.cwd)],
+                ["autoDocs", String(view.autoDocs)],
+                ["Enabled", String(view.enabled)],
+                ["Dirty", String(view.dirty)],
+                ["Pending", String(view.pending)],
+                ["Last sync", String(view.lastSync)]
+            ])
+        ];
+        if (outcome) {
+            lines.push("", ui.kv([
+                ["Action", outcome.status],
+                ["Reason", outcome.reason],
+                ["Docs", outcome.docsPath ? `${outcome.docsPath}${outcome.docsUpdated ? " updated" : " unchanged"}` : "n/a"],
+                ["Memory", outcome.memorySlot ?? "n/a"]
+            ]));
+            lines.push("", outcome.status === "failed" ? ui.style("red", outcome.reason) : ui.style("green", outcome.reason));
+        }
+        else {
+            lines.push("", ui.style("dim", "Use --flush to sync, --mark <path> to record a change."));
+        }
+        return lines.join("\n");
+    });
+    if (outcome?.status === "failed")
+        process.exitCode = 1;
+}

package/dist/commands/clean.js

@@ -0,0 +1,106 @@
+import { statSync } from "node:fs";
+import { join } from "node:path";
+import { asString, confirm, dbPathFor, emit, flagOn, numberFlag, print } from "./context.js";
+import { loadSpec, NovahizHome } from "../spec.js";
+import { openDb } from "../db.js";
+import * as ui from "../render.js";
+const CLEAN_SCOPES = {
+    logs: [
+        { table: "enforcement_log", column: "logged_at", label: "enforcement log" },
+        { table: "skill_invocations", column: "invoked_at", label: "skill invocations" }
+    ],
+    roadmap: [{ table: "roadmap_progress", column: "updated_at", label: "roadmap progress" }],
+    sessions: [{ table: "sessions", column: "updated_at", label: "sessions" }],
+    tasks: [{ table: "tasks", column: "created_at", where: "status <> 'active'", label: "completed tasks" }]
+};
+const CLEAN_CHOICES = ["logs", "roadmap", "sessions", "tasks", "all"];
+export function commandClean(parsed) {
+    const root = NovahizHome();
+    const spec = loadSpec(root);
+    const path = dbPathFor(root, spec);
+    const daysRaw = numberFlag(parsed, "days", { min: 1, integer: true });
+    const days = daysRaw !== undefined && daysRaw > 0 ? Math.floor(daysRaw) : 30;
+    const targetRaw = (asString(parsed.flags.target) || "logs").toLowerCase();
+    if (!CLEAN_CHOICES.includes(targetRaw)) {
+        print({ error: `unknown target: ${targetRaw}`, choices: CLEAN_CHOICES });
+        process.exitCode = 1;
+        return;
+    }
+    const scopes = targetRaw === "all" ? Object.values(CLEAN_SCOPES).flat() : CLEAN_SCOPES[targetRaw];
+    const vacuum = flagOn(parsed, "vacuum");
+    const apply = flagOn(parsed, "apply");
+    const cutoff = new Date(Date.now() - days * 86_400_000).toISOString();
+    // M13: only allow known tables from CLEAN_SCOPES to prevent SQL injection
+    // via --target values. The CLEAN_CHOICES check above already gates this,
+    // but we validate at the SQL layer too for defense-in-depth.
+    const SAFE_TABLES = new Set(Object.values(CLEAN_SCOPES).flat().map((s) => s.table));
+    const db = openDb(path);
+    const before = statSync(path).size;
+    const plan = scopes.map((scope) => {
+        if (!SAFE_TABLES.has(scope.table))
+            throw new Error(`unsafe table: ${scope.table}`);
+        const where = `${scope.column} < ?${scope.where ? ` AND ${scope.where}` : ""}`;
+        const rows = db.prepare(`SELECT COUNT(*) AS n FROM ${scope.table}`).get().n;
+        const deletable = db.prepare(`SELECT COUNT(*) AS n FROM ${scope.table} WHERE ${where}`).get(cutoff).n;
+        return { table: scope.table, label: scope.label, rows, deletable };
+    });
+    const total = plan.reduce((sum, entry) => sum + entry.deletable, 0);
+    const renderPlan = () => {
+        const lines = [
+            ui.heading("novahiz clean"),
+            ui.kv([
+                ["Base", `${path} (${ui.bytes(before)})`],
+                ["Target", targetRaw],
+                ["Age", `older than ${days} days, before ${cutoff}`],
+                ["To delete", `${total} line(s)`]
+            ]),
+            "",
+            ui.table(["table", "rows", "to delete"], plan.map((entry) => [entry.table, String(entry.rows), String(entry.deletable)])),
+            ""
+        ];
+        if (targetRaw === "tasks" || targetRaw === "all") {
+            lines.push(ui.style("dim", "Orphan todos of deleted tasks are removed with them."));
+        }
+        return lines.join("\n");
+    };
+    if (!apply) {
+        const interactive = process.stdin.isTTY === true;
+        const explicitDryRun = flagOn(parsed, "dry-run");
+        if (!interactive) {
+            db.close();
+            emit(parsed, { path, days, cutoff, target: targetRaw, vacuum, applied: false, bytesBefore: before, bytesAfter: before, deleted: 0, tables: plan }, () => [renderPlan(), ui.style("dim", "Plan mode. Restart with --apply to delete.")].join("\n"));
+            if (!explicitDryRun) {
+                process.stderr.write("Non-interactive input: add --apply to delete, or --dry-run to keep only the preview.\n");
+                process.exitCode = 1;
+            }
+            return;
+        }
+        process.stdout.write(`${renderPlan()}\n`);
+        if (!confirm("Delete these rows?")) {
+            db.close();
+            process.stdout.write(`${ui.style("yellow", "Canceled.")}\n`);
+            return;
+        }
+    }
+    let deleted = 0;
+    for (const scope of scopes) {
+        const where = `${scope.column} < ?${scope.where ? ` AND ${scope.where}` : ""}`;
+        deleted += Number(db.prepare(`DELETE FROM ${scope.table} WHERE ${where}`).run(cutoff).changes);
+    }
+    if (targetRaw === "tasks" || targetRaw === "all") {
+        deleted += Number(db.prepare("DELETE FROM todos WHERE task_id NOT IN (SELECT id FROM tasks)").run().changes);
+    }
+    if (vacuum)
+        db.exec("VACUUM");
+    db.close();
+    const after = statSync(path).size;
+    const value = { path, days, cutoff, target: targetRaw, vacuum, applied: true, bytesBefore: before, bytesAfter: after, deleted, tables: plan };
+    emit(parsed, value, () => [
+        renderPlan(),
+        ui.kv([
+            ["Deleted", `${deleted} line(s)`],
+            ["Size", `${ui.bytes(before)} to ${ui.bytes(after)}`],
+            ["Vacuum", vacuum ? "yes" : "no"]
+        ])
+    ].join("\n"));
+}