novahiz 0.3.1 → 0.3.3

package/dist/classify.js

@@ -0,0 +1,181 @@
+import { providersForCategories } from "./providers.js";
+import { determineTier } from "./complexity.js";
+export function fold(value) {
+    return value
+        .toLowerCase()
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "");
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function termMatches(text, keyword) {
+    const needle = fold(keyword).trim();
+    if (needle.length === 0)
+        return false;
+    const pattern = new RegExp(`(^|[^\\p{L}\\p{N}])${escapeRegex(needle)}([^\\p{L}\\p{N}]|$)`, "u");
+    return pattern.test(text);
+}
+function keywordTerm(keyword) {
+    return typeof keyword === "string" ? keyword : keyword.term;
+}
+function keywordWeight(keyword) {
+    if (typeof keyword === "string")
+        return 1;
+    return typeof keyword.weight === "number" ? keyword.weight : 1;
+}
+function matchedAlternative(text, keyword) {
+    const raw = keywordTerm(keyword);
+    const alternatives = raw.includes("|") ? raw.split("|") : [raw];
+    for (const alternative of alternatives) {
+        const term = alternative.trim();
+        if (term.length > 0 && termMatches(text, term))
+            return term;
+    }
+    return null;
+}
+function byCodeUnit(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+// Confidence maps a raw keyword score to [0, 1) using a half-saturation curve.
+// At score=2 the confidence is ~0.5; at score=5 it's ~0.71; at score=10 it's ~0.83.
+// The "+2" constant prevents low-score categories from having disproportionate confidence.
+function confidence(score) {
+    if (score <= 0)
+        return 0;
+    return Math.round((score / (score + 2)) * 100) / 100;
+}
+function skillsOfCategory(category) {
+    const skills = [...category.defaultSkills];
+    for (const step of category.roadmap?.steps ?? []) {
+        for (const skill of step.requireSkills ?? []) {
+            if (!skills.includes(skill))
+                skills.push(skill);
+        }
+    }
+    return skills;
+}
+function enforcedOfCategory(category) {
+    const skills = [];
+    for (const step of category.roadmap?.steps ?? []) {
+        if (step.kind !== "skill" || step.optional)
+            continue;
+        for (const skill of step.requireSkills ?? []) {
+            if (!skills.includes(skill))
+                skills.push(skill);
+        }
+    }
+    return skills;
+}
+export function classify(spec, prompt, options = {}) {
+    const minScore = options.minScore ?? spec.config.classify.minScore;
+    const maxCategories = options.maxCategories ?? spec.config.classify.maxCategories;
+    const fallbackCategory = options.fallbackCategory ?? spec.config.classify.fallbackCategory;
+    const text = fold(prompt);
+    // Determine complexity tier
+    const tier = determineTier(prompt);
+    const scored = [];
+    for (const category of spec.categories) {
+        let score = 0;
+        const terms = [];
+        const negatives = [];
+        for (const keyword of category.keywords) {
+            const matched = matchedAlternative(text, keyword);
+            if (!matched)
+                continue;
+            let weight = keywordWeight(keyword);
+            if (matched.includes(" "))
+                weight += 0.5;
+            score += weight;
+            terms.push(matched);
+        }
+        for (const negative of category.negativeKeywords ?? []) {
+            const matched = matchedAlternative(text, negative);
+            if (!matched)
+                continue;
+            score -= keywordWeight(negative);
+            negatives.push(matched);
+        }
+        if (score >= minScore) {
+            scored.push({ id: category.id, score, confidence: confidence(score), margin: 0, terms, negatives });
+        }
+    }
+    const priorityOf = (id) => spec.categories.find((category) => category.id === id)?.priority ?? 0;
+    scored.sort((a, b) => b.score - a.score || priorityOf(b.id) - priorityOf(a.id) || byCodeUnit(a.id, b.id));
+    for (let index = 0; index < scored.length; index += 1) {
+        const next = scored[index + 1]?.score ?? 0;
+        scored[index].margin = Math.round((scored[index].score - next) * 1000) / 1000;
+    }
+    const selected = scored.slice(0, Math.max(0, maxCategories));
+    // H8: when nothing matched and fallback is misconfigured, force "general" so
+    // the gate still applies R6 rules instead of silently allowing everything.
+    if (selected.length === 0) {
+        if (fallbackCategory.length > 0 && spec.categories.some((entry) => entry.id === fallbackCategory)) {
+            selected.push({ id: fallbackCategory, score: 0, confidence: 0, margin: 0, terms: [], negatives: [] });
+        }
+        else if (spec.categories.some((entry) => entry.id === "general")) {
+            selected.push({ id: "general", score: 0, confidence: 0, margin: 0, terms: [], negatives: [] });
+        }
+    }
+    const requiredSkills = [];
+    const invocations = [];
+    const roadmaps = [];
+    for (const item of selected) {
+        const category = spec.categories.find((entry) => entry.id === item.id);
+        if (!category)
+            continue;
+        // Tier-based skill filtering
+        if (tier === "trivial") {
+            // Trivial: no skills required from roadmap
+            continue;
+        }
+        if (tier === "lite") {
+            // Lite: only implement + converge skills (skip plan, clarify, etc.)
+            for (const step of category.roadmap?.steps ?? []) {
+                const allowed = (step.requireSkills ?? []).filter(s => s === "novahiz-implement" || s === "novahiz-converge");
+                for (const skill of allowed) {
+                    if (!requiredSkills.includes(skill))
+                        requiredSkills.push(skill);
+                }
+            }
+        }
+        else {
+            // Full: all skills
+            for (const skill of skillsOfCategory(category)) {
+                if (!requiredSkills.includes(skill))
+                    requiredSkills.push(skill);
+            }
+        }
+        for (const step of category.roadmap?.steps ?? []) {
+            if (step.kind !== "skill")
+                continue;
+            invocations.push({
+                category: category.id,
+                step: step.id,
+                label: step.label,
+                kind: step.kind,
+                skills: step.requireSkills ?? [],
+                optional: step.optional === true
+            });
+        }
+        if (category.roadmap) {
+            roadmaps.push({ category: category.id, id: category.roadmap.id, steps: category.roadmap.steps });
+        }
+    }
+    const primary = selected[0]?.id ?? null;
+    const primaryCategory = primary ? spec.categories.find((entry) => entry.id === primary) : undefined;
+    // C1: enforcedSkills must respect tier gating — trivial prompts should not
+    // expose enforced skills, otherwise downstream consumers load skills unnecessarily.
+    const enforcedSkills = (tier !== "trivial" && primaryCategory) ? enforcedOfCategory(primaryCategory) : [];
+    const providers = providersForCategories(spec, selected.map((entry) => entry.id)).map((provider) => provider.id);
+    return {
+        categories: selected,
+        primary,
+        tier,
+        requiredSkills,
+        enforcedSkills,
+        invocations,
+        providers,
+        roadmaps
+    };
+}

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;
+}