novahiz 0.3.2 → 0.3.3

package/dist/commands/graft.js

@@ -0,0 +1,146 @@
+/**
+ * `novahiz graft` — version-control the SQLite ledger via graft.
+ *
+ * Subcommands: init, log, diff, status, restore, export, commit
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { NovahizHome } from "../spec.js";
+import { isGraftAvailable, isGraftInitialized, initGraft, commitGraft, getGraftLog, getGraftDiff, getGraftStatus, restoreGraft, exportGraft, } from "../graft.js";
+const HELP = `novahiz graft — version-control the SQLite ledger
+
+Usage:
+  novahiz graft init             Initialize graft repository
+  novahiz graft log [N]          Show last N commits (default: 20)
+  novahiz graft diff             Diff current ledger vs last commit
+  novahiz graft status           Show graft status
+  novahiz graft restore <hash> [--force]  Restore ledger to a revision (--force required; a backup is written first)
+  novahiz graft export <hash> <path> [--force]  Export snapshot as .sqlite (path must stay in the workspace; --force to overwrite)
+  novahiz graft commit -m MSG   Manual commit with message
+  novahiz graft help             Show this help
+`;
+function fail(msg) {
+    console.error(`error: ${msg}`);
+    process.exitCode = 1;
+}
+export function graftCommand(argv) {
+    const sub = argv[0] ?? "help";
+    if (sub === "help" || sub === "--help" || sub === "-h") {
+        console.log(HELP);
+        return;
+    }
+    if (!isGraftAvailable()) {
+        fail("graft CLI not found on PATH. Install: npm install -g @eidos.space/graft");
+    }
+    switch (sub) {
+        case "init": {
+            const result = initGraft();
+            if (result.success) {
+                console.log(`ok: ${result.message}`);
+            }
+            else {
+                fail(result.message);
+            }
+            break;
+        }
+        case "log": {
+            if (!isGraftInitialized()) {
+                fail("graft not initialized. Run: novahiz graft init");
+            }
+            const limit = parseInt(argv[1] ?? "20", 10) || 20;
+            const entries = getGraftLog(limit);
+            if (entries.length === 0) {
+                console.log("no commits yet");
+                return;
+            }
+            for (const e of entries) {
+                console.log(`\x1b[33m${e.hash}\x1b[0m ${e.date}`);
+                console.log(`  ${e.message}`);
+            }
+            break;
+        }
+        case "diff": {
+            if (!isGraftInitialized()) {
+                fail("graft not initialized. Run: novahiz graft init");
+            }
+            const diff = getGraftDiff();
+            console.log(diff);
+            break;
+        }
+        case "status": {
+            if (!isGraftInitialized()) {
+                fail("graft not initialized. Run: novahiz graft init");
+            }
+            const status = getGraftStatus();
+            console.log(status);
+            break;
+        }
+        case "restore": {
+            if (!isGraftInitialized()) {
+                fail("graft not initialized. Run: novahiz graft init");
+            }
+            const force = argv.slice(1).includes("--force");
+            const rev = argv.slice(1).find((a) => a !== "--force");
+            if (!rev) {
+                fail("usage: novahiz graft restore <revision> [--force]");
+                return;
+            }
+            const result = restoreGraft(rev, { force });
+            if (result.success) {
+                console.log(`ok: ${result.message}`);
+            }
+            else {
+                fail(result.message);
+            }
+            break;
+        }
+        case "export": {
+            if (!isGraftInitialized()) {
+                fail("graft not initialized. Run: novahiz graft init");
+            }
+            const rest = argv.slice(1).filter((a) => a !== "--force");
+            const force = argv.slice(1).includes("--force");
+            const rev = rest[0];
+            const outPath = rest[1];
+            if (!rev || !outPath) {
+                fail("usage: novahiz graft export <revision> <output-path> [--force]");
+                return;
+            }
+            const result = exportGraft(rev, outPath, { force });
+            if (result.success) {
+                console.log(`ok: ${result.message}`);
+            }
+            else {
+                fail(result.message);
+            }
+            break;
+        }
+        case "commit": {
+            if (!isGraftInitialized()) {
+                fail("graft not initialized. Run: novahiz graft init");
+            }
+            // Parse -m flag
+            let msg = "";
+            for (let i = 1; i < argv.length; i++) {
+                if (argv[i] === "-m" && argv[i + 1]) {
+                    msg = argv[i + 1];
+                    break;
+                }
+            }
+            if (!msg) {
+                fail("usage: novahiz graft commit -m <message>");
+            }
+            const result = commitGraft(msg);
+            if (result) {
+                console.log(`[${result.hash}] ${result.message}`);
+            }
+            else {
+                console.log("nothing to commit");
+            }
+            break;
+        }
+        default:
+            fail(`unknown subcommand: ${sub}. Use 'novahiz graft help'`);
+    }
+}

package/dist/commands/init.js

@@ -0,0 +1,325 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+import { emit, flagOn } from "./context.js";
+import { NovahizHome } from "../spec.js";
+import { ensureMemoryRoot, memoryRoot, writeEntry } from "../memory.js";
+import { ensureProjectAutoDocsConfig } from "./autodocs.js";
+import * as ui from "../render.js";
+const DOC_FILES = ["ARCHITECTURE.md", "CONVENTIONS.md", "DECISIONS.md", "STANDARDS.md"];
+const CLEANUP_PATTERNS = [
+    { pattern: /^\.DS_Store$/, reason: "macOS folder metadata" },
+    { pattern: /^Thumbs\.db$/i, reason: "Windows thumbnail cache" },
+    { pattern: /\.orig$/i, reason: "merge leftover" },
+    { pattern: /\.rej$/i, reason: "patch reject leftover" },
+    { pattern: /^npm-debug\.log.*$/i, reason: "npm debug log" },
+    { pattern: /^yarn-error\.log.*$/i, reason: "yarn error log" },
+    { pattern: /^.*\.novahiz-bak$/i, reason: "Novahiz installer backup" }
+];
+function detectProject(cwd) {
+    const markers = [];
+    let name = "";
+    let version = "";
+    let kind = "unknown";
+    const pkgPath = join(cwd, "package.json");
+    if (existsSync(pkgPath)) {
+        markers.push("package.json");
+        kind = "node";
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+            name = typeof pkg.name === "string" ? pkg.name : "";
+            version = typeof pkg.version === "string" ? pkg.version : "";
+        }
+        catch {
+            // name falls back to the folder below
+        }
+    }
+    if (existsSync(join(cwd, "Cargo.toml"))) {
+        markers.push("Cargo.toml");
+        if (kind === "unknown")
+            kind = "rust";
+    }
+    if (existsSync(join(cwd, "pyproject.toml")) || existsSync(join(cwd, "requirements.txt"))) {
+        markers.push("python-manifest");
+        if (kind === "unknown")
+            kind = "python";
+    }
+    if (existsSync(join(cwd, "go.mod"))) {
+        markers.push("go.mod");
+        if (kind === "unknown")
+            kind = "go";
+    }
+    if (existsSync(join(cwd, ".git")))
+        markers.push(".git");
+    if (existsSync(join(cwd, "README.md")))
+        markers.push("README.md");
+    if (!name) {
+        name = cwd.split(/[\\/]/).filter(Boolean).pop() ?? "project";
+    }
+    return { kind, name, version, markers };
+}
+function scanCleanup(cwd) {
+    const candidates = [];
+    const skipDirs = new Set(["node_modules", ".git", "project-memory", "novahiz-docs", "dist", "build", ".next", "coverage"]);
+    const walk = (dir, depth) => {
+        if (depth > 3)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (skipDirs.has(entry))
+                continue;
+            const full = join(dir, entry);
+            let isDir = false;
+            try {
+                isDir = statSync(full).isDirectory();
+            }
+            catch {
+                continue;
+            }
+            if (isDir) {
+                walk(full, depth + 1);
+                continue;
+            }
+            for (const { pattern, reason } of CLEANUP_PATTERNS) {
+                if (pattern.test(entry)) {
+                    candidates.push({ path: relative(cwd, full).split("\\").join("/"), reason });
+                    break;
+                }
+            }
+        }
+    };
+    walk(cwd, 0);
+    return candidates.sort((a, b) => a.path.localeCompare(b.path));
+}
+function copyDocs(templatesDir, targetDir, dryRun) {
+    if (!existsSync(templatesDir)) {
+        return { id: "docs", label: "Documentation skeleton", status: "failed", detail: `templates missing: ${templatesDir}` };
+    }
+    if (existsSync(targetDir)) {
+        const existing = readdirSync(targetDir).filter((name) => name.endsWith(".md"));
+        return {
+            id: "docs",
+            label: "Documentation skeleton",
+            status: "skipped",
+            detail: `novahiz-docs/ already has ${existing.length} file(s)`
+        };
+    }
+    if (dryRun) {
+        return {
+            id: "docs",
+            label: "Documentation skeleton",
+            status: "dry-run",
+            detail: `would create ${DOC_FILES.length} files under novahiz-docs/`
+        };
+    }
+    try {
+        mkdirSync(targetDir, { recursive: true });
+        for (const file of DOC_FILES) {
+            const src = join(templatesDir, file);
+            if (existsSync(src))
+                copyFileSync(src, join(targetDir, file));
+        }
+        return {
+            id: "docs",
+            label: "Documentation skeleton",
+            status: "created",
+            detail: `${DOC_FILES.length} files in novahiz-docs/`
+        };
+    }
+    catch (error) {
+        return {
+            id: "docs",
+            label: "Documentation skeleton",
+            status: "failed",
+            detail: error.message
+        };
+    }
+}
+function initMemory(cwd, dryRun, seed, project) {
+    const root = memoryRoot(cwd);
+    if (dryRun) {
+        const present = existsSync(root);
+        return {
+            id: "memory",
+            label: "Project memory",
+            status: "dry-run",
+            detail: present ? "project-memory/ already present, seed would append" : "would create project-memory/"
+        };
+    }
+    try {
+        const index = ensureMemoryRoot(root);
+        const seeded = index.slots.length === 0 && seed;
+        if (seeded) {
+            const stackLine = project.markers.length > 0 ? project.markers.join(", ") : "no manifest detected";
+            writeEntry({
+                title: "Project baseline",
+                description: `Initial memory for ${project.name}`,
+                tags: ["init", project.kind],
+                root,
+                content: [
+                    `Name: ${project.name}`,
+                    project.version ? `Version: ${project.version}` : null,
+                    `Kind: ${project.kind}`,
+                    `Markers: ${stackLine}`,
+                    `Initialized: ${new Date().toISOString()}`,
+                    "",
+                    "Next: fill novahiz-docs/ from a deep read of the codebase (skill novahiz-init)."
+                ]
+                    .filter((line) => line !== null)
+                    .join("\n")
+            });
+        }
+        return {
+            id: "memory",
+            label: "Project memory",
+            status: "created",
+            detail: seeded ? "project-memory/ created with baseline slot" : `project-memory/ ready (${index.slots.length} slot(s))`
+        };
+    }
+    catch (error) {
+        return {
+            id: "memory",
+            label: "Project memory",
+            status: "failed",
+            detail: error.message
+        };
+    }
+}
+function projectDoctor(project) {
+    if (project.markers.length === 0) {
+        return {
+            id: "doctor",
+            label: "Project detection",
+            status: "failed",
+            detail: "no package.json, Cargo.toml, pyproject.toml, go.mod, or .git in cwd"
+        };
+    }
+    return {
+        id: "doctor",
+        label: "Project detection",
+        status: "created",
+        detail: `${project.kind}: ${project.name}${project.version ? `@${project.version}` : ""} (${project.markers.join(", ")})`
+    };
+}
+export function commandInit(parsed) {
+    const cwd = process.cwd();
+    const home = NovahizHome();
+    const dryRun = flagOn(parsed, "dry-run");
+    const docsOnly = flagOn(parsed, "docs-only");
+    const memoryOnly = flagOn(parsed, "memory-only");
+    const noSeed = flagOn(parsed, "no-seed");
+    const applyCleanup = flagOn(parsed, "apply") && !dryRun;
+    const project = detectProject(cwd);
+    const steps = [];
+    steps.push(projectDoctor(project));
+    const runMemory = !docsOnly;
+    const runDocs = !memoryOnly;
+    const runCleanup = !docsOnly && !memoryOnly;
+    if (runMemory)
+        steps.push(initMemory(cwd, dryRun, !noSeed, project));
+    if (runDocs) {
+        const templates = join(home, "skills", "novahiz-docs", "templates");
+        steps.push(copyDocs(templates, join(cwd, "novahiz-docs"), dryRun));
+    }
+    if (!docsOnly && !memoryOnly) {
+        if (dryRun) {
+            steps.push({
+                id: "autodocs",
+                label: "Auto docs config",
+                status: "dry-run",
+                detail: "would write .novahiz/config.json with autoDocs=true"
+            });
+        }
+        else {
+            const status = ensureProjectAutoDocsConfig(cwd);
+            steps.push({
+                id: "autodocs",
+                label: "Auto docs config",
+                status: status === "failed" ? "failed" : status === "created" ? "created" : "skipped",
+                detail: status === "failed" ? "could not write .novahiz/config.json" : `.novahiz/config.json ${status}`
+            });
+        }
+    }
+    let cleanup = [];
+    let cleanupApplied = 0;
+    if (runCleanup) {
+        cleanup = scanCleanup(cwd);
+        if (applyCleanup && cleanup.length > 0) {
+            const removed = [];
+            for (const candidate of cleanup) {
+                try {
+                    rmSync(join(cwd, candidate.path), { force: true });
+                    removed.push(candidate.path);
+                }
+                catch {
+                    // keep going; the count reflects what succeeded
+                }
+            }
+            cleanupApplied = removed.length;
+            cleanup = cleanup.filter((item) => !removed.includes(item.path));
+        }
+        steps.push({
+            id: "cleanup",
+            label: "Cleanup candidates",
+            status: applyCleanup ? "created" : dryRun || cleanup.length > 0 ? "dry-run" : "skipped",
+            detail: applyCleanup
+                ? `removed ${cleanupApplied} file(s)`
+                : cleanup.length > 0
+                    ? `${cleanup.length} candidate(s), none deleted (use --apply after review)`
+                    : "nothing safe to propose"
+        });
+    }
+    else {
+        steps.push({ id: "cleanup", label: "Cleanup candidates", status: "skipped", detail: "skipped by scope flag" });
+    }
+    const failed = steps.filter((step) => step.status === "failed");
+    const value = {
+        cwd,
+        home,
+        dryRun,
+        project,
+        steps,
+        cleanup,
+        cleanupApplied,
+        next: failed.length === 0 ? "Run the novahiz-init skill in an agent to fill docs and deepen memory." : null,
+        failed: failed.map((step) => step.id)
+    };
+    emit(parsed, value, () => {
+        const lines = [
+            ui.heading(dryRun ? "novahiz init (dry-run)" : "novahiz init"),
+            ui.kv([
+                ["Project", `${project.name}${project.version ? `@${project.version}` : ""}`],
+                ["Cwd", cwd],
+                ["Home", home]
+            ]),
+            "",
+            ui.table(["step", "status", "detail"], steps.map((step) => [
+                step.label,
+                step.status === "failed"
+                    ? ui.status(false)
+                    : step.status === "created"
+                        ? ui.status(true)
+                        : ui.style("dim", step.status),
+                step.detail
+            ])),
+            ""
+        ];
+        if (cleanup.length > 0 && !applyCleanup) {
+            lines.push(ui.heading("Cleanup (not applied)"));
+            for (const item of cleanup)
+                lines.push(`  ${item.path}  ${ui.style("dim", item.reason)}`);
+            lines.push("");
+        }
+        lines.push(failed.length > 0
+            ? ui.style("red", `${failed.length} step(s) failed.`)
+            : ui.style("green", dryRun ? "Dry-run only. Re-run without --dry-run to write." : "Scaffold ready. Load the novahiz-init skill to finish."));
+        return lines.join("\n");
+    });
+    if (failed.length > 0)
+        process.exitCode = 1;
+}