novahiz 0.2.2 → 0.2.5

package/adapters/README.md

@@ -4,7 +4,7 @@ Novahiz keeps every decision in the CLI. An adapter only translates a harness ev
 
 ## opencode
 
-`adapters/opencode/novahiz.ts` is a plugin. It classifies each user message, injects the roadmap checklist and expected skills, tracks loaded skills per session, and calls `Novahiz gate` on `edit`, `write`, `patch`, `apply_patch`, `bash`, and `shell`. The gate is content-aware, so `novahiz-humanizer` is required only when the change contains prose. It registers the MCP server through the plugin `config` hook, and persists every skill launch with `Novahiz session-load`.
+`adapters/opencode/novahiz.ts` is a plugin. It classifies each user message, injects the roadmap checklist and expected skills, tracks loaded skills per session, and calls `Novahiz gate` on `edit`, `write`, `patch`, `apply_patch`, `bash`, and `shell`. The gate requires `novahiz-humanizer`, `ui-slop-remover` and `ui-craft-rules` only on frontend design tasks (R13). It registers the MCP server through the plugin `config` hook, and persists every skill launch with `Novahiz session-load`.
 
 `adapters/opencode/agent/novahiz.md` is the primary agent. It carries `permission: { question: allow, plan_enter: allow }`, because opencode denies `question` to every agent by default and only its built-in `build` and `plan` agents re-allow it.
 

package/adapters/opencode/agent/novahiz.md

@@ -25,8 +25,7 @@ Work in this order for every request:
 
 Rules:
 
-- Humanizer is required for any text meant for a reader; never for raw navigation or research.
-- anti-AI-design and frontend-design-taste are required for design work (R13-design-craft); impeccable is not installed.
+- novahiz-humanizer, ui-slop-remover and ui-craft-rules are required only for frontend design tasks (R13-design-craft); impeccable is not installed.
 - Load the Supabase skills for any Supabase work.
 - Be honest. Avoid false good ideas. Keep a critical stance. Zero simulation: never pretend to have run, tested, or verified something you did not.
 - Criticize the request when it is inconsistent, ambiguous, risky, or suboptimal, and propose an alternative.

package/adapters/opencode/commands/novahiz-init.md

@@ -0,0 +1,10 @@
+---
+description: Initialize Novahiz in this project (memory, docs, analysis, reviewed cleanup)
+---
+
+Load the `novahiz-init` skill and follow its pipeline from the current working directory.
+
+1. Run `novahiz init --dry-run --json` and show the plan.
+2. Unless the user only wanted a preview, run `novahiz init --json`.
+3. Deep-read the project (`novahiz-analyse`), fill `novahiz-docs/`, seed memory.
+4. Offer cleanup only after listing candidates; apply solely on explicit consent.

package/adapters/opencode/instructions.md

@@ -28,7 +28,7 @@ Playwright uses a **persistent profile** that preserves data across sessions (co
 
 ## Behavioral & Quality Rules
 
-1. **Mandatory humanizer on text and code** — On every code or text modification meant for a reader, load the `novahiz-humanizer` skill and apply its rules (remove AI writing tics: not-X-but-Y contrasts, forced triads, excessive dashes, empty phrases, marketing jargon). Browser tasks (navigation, search, extraction) proceed as direct actions without a roadmap.
+1. **Mandatory design skills on frontend design tasks** — `novahiz-humanizer`, `ui-slop-remover` and `ui-craft-rules` are required only on frontend design work (design-ui prompts and style files). Load them with `skill({name})` before any design edit. Outside design, they are not required by the gate. Browser tasks (navigation, search, extraction) proceed as direct actions without a roadmap.
 2. **Supabase** — On any Supabase task (database, auth, RLS, Edge Functions, migrations, Storage, Realtime, CLI/MCP), load the `novahiz-supabase` and `novahiz-postgres` skills before acting.
 5. **Honesty and critical thinking** — Always be honest. Avoid false good ideas. Maintain critical thinking. **Zero simulation objective:** never claim to have executed, tested, or verified what was not. Explicitly report uncertainties and assumptions.
 6. **Propose next steps** — After completing a task, always honestly propose the relevant next step. Do not invent unnecessary work or mask failures.

package/adapters/opencode/novahiz.ts

@@ -1,10 +1,11 @@
 import type { Plugin } from "@opencode-ai/plugin";
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { join, relative, resolve } from "node:path";
 
-// Inlined from src/prompt-rewriter.ts to avoid broken relative path in installed plugin
+// Inlined from src/prompt-rewriter.ts — the installed plugin lives in
+// ~/.config/opencode/plugins/ and cannot resolve ../../src/*.
 type RewriteResult = { original: string; rewritten: string; sourceLanguage: string; wasRewritten: boolean };
 
 function detectLanguage(prompt: string): string {
@@ -50,6 +51,138 @@ function rewritePrompt(prompt: string): RewriteResult {
   return { original: prompt, rewritten: r, sourceLanguage, wasRewritten: true };
 }
 
+// Inlined from src/autodocs.ts — same reason as prompt-rewriter: relative
+// imports to ../../src break once the plugin is copied into opencode's plugins/.
+const NOVAHIZ_DIR = ".novahiz";
+const STATE_NAME = "state.json";
+const CONFIG_NAME = "config.json";
+
+type AutoDocsState = {
+  dirty: boolean;
+  pending: string[];
+  lastSync: string | null;
+  sessions: number;
+};
+
+const EMPTY_STATE: AutoDocsState = { dirty: false, pending: [], lastSync: null, sessions: 0 };
+const MAJOR_DIRS = /^(src|lib|app|routes|pages|api|server|internal|pkg|cmd)\//;
+const MAJOR_FILES = new Set([
+  "package.json",
+  "pyproject.toml",
+  "Cargo.toml",
+  "go.mod",
+  "composer.json",
+  "Gemfile"
+]);
+const MAJOR_EXT = new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".rs",
+  ".go",
+  ".php",
+  ".rb",
+  ".java",
+  ".kt",
+  ".swift",
+  ".dart",
+  ".sql"
+]);
+const SKIP_DIRS = new Set([
+  "node_modules",
+  ".git",
+  "project-memory",
+  "novahiz-docs",
+  ".novahiz",
+  "dist",
+  "build",
+  "coverage",
+  ".next"
+]);
+
+function projectDir(cwd: string): string {
+  return join(cwd, NOVAHIZ_DIR);
+}
+
+function configPath(cwd: string): string {
+  return join(projectDir(cwd), CONFIG_NAME);
+}
+
+function statePath(cwd: string): string {
+  return join(projectDir(cwd), STATE_NAME);
+}
+
+function ensureNovahizDir(path: string): void {
+  if (!existsSync(path)) mkdirSync(path, { recursive: true });
+}
+
+function autoDocsEnabled(cwd: string): boolean {
+  const escape = (process.env.NOVAHIZ_AUTODOCS ?? "").toLowerCase();
+  if (["off", "0", "false", "no", "disabled"].includes(escape)) return false;
+  try {
+    const parsed = JSON.parse(readFileSync(configPath(cwd), "utf8")) as { autoDocs?: unknown };
+    return parsed !== null && typeof parsed === "object" && parsed.autoDocs === true;
+  } catch {
+    return false;
+  }
+}
+
+function readState(cwd: string): AutoDocsState {
+  try {
+    const parsed = JSON.parse(readFileSync(statePath(cwd), "utf8")) as Partial<AutoDocsState>;
+    if (!parsed || typeof parsed !== "object") return { ...EMPTY_STATE };
+    return {
+      dirty: parsed.dirty === true,
+      pending: Array.isArray(parsed.pending)
+        ? parsed.pending.filter((entry): entry is string => typeof entry === "string").slice(0, 64)
+        : [],
+      lastSync: typeof parsed.lastSync === "string" ? parsed.lastSync : null,
+      sessions: typeof parsed.sessions === "number" && Number.isFinite(parsed.sessions) ? parsed.sessions : 0
+    };
+  } catch {
+    return { ...EMPTY_STATE };
+  }
+}
+
+function writeState(cwd: string, state: AutoDocsState): void {
+  ensureNovahizDir(projectDir(cwd));
+  writeFileSync(statePath(cwd), `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+
+function normalizePath(filePath: string): string {
+  return filePath.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
+}
+
+function isMajorPath(filePath: string): boolean {
+  const path = normalizePath(filePath);
+  const parts = path.split("/");
+  if (parts.some((part) => SKIP_DIRS.has(part))) return false;
+  const base = parts[parts.length - 1] ?? "";
+  if (MAJOR_FILES.has(base)) return true;
+  const dot = base.lastIndexOf(".");
+  const ext = dot >= 0 ? base.slice(dot).toLowerCase() : "";
+  if (MAJOR_EXT.has(ext)) return true;
+  return MAJOR_DIRS.test(path);
+}
+
+function markDirty(cwd: string, filePath: string): AutoDocsState {
+  const path = normalizePath(filePath);
+  const state = readState(cwd);
+  const pending = state.pending.includes(path) ? state.pending : [...state.pending, path].slice(-64);
+  const next: AutoDocsState = {
+    ...state,
+    dirty: true,
+    pending,
+    sessions: state.sessions + 1
+  };
+  writeState(cwd, next);
+  return next;
+}
+
 function ensureProjectMemory(cwd: string): boolean {
   try {
     const root = join(cwd, "project-memory");
@@ -219,6 +352,28 @@ export const NovahizPlugin: Plugin = async ({ client }) => {
 
     event: async ({ event }) => {
       const type = (event as { type?: string }).type ?? "";
+      if (type === "session.idle") {
+        // Fail-open: never block idle; skip when disabled or nothing pending.
+        try {
+          const cwd = process.cwd();
+          if (autoDocsEnabled(cwd)) {
+            const state = readState(cwd);
+            if (state.dirty || state.pending.length > 0) {
+              const child = spawn(NODE, [CLI, "autodocs", "--flush"], {
+                cwd,
+                stdio: "ignore",
+                timeout: RUN_TIMEOUT_MS,
+                windowsHide: true
+              });
+              child.on("error", () => undefined);
+              child.unref();
+            }
+          }
+        } catch {
+          // fail-open
+        }
+        return;
+      }
       if (type !== "session.deleted") return;
       const properties = (event as { properties?: { info?: { id?: string }; sessionID?: string } }).properties ?? {};
       const sessionID = properties.info?.id ?? properties.sessionID;
@@ -302,7 +457,7 @@ export const NovahizPlugin: Plugin = async ({ client }) => {
           }
         }
         lines.push("The gate blocks edit/write/patch/apply_patch/bash/shell until the required skills are loaded via skill({name:\"...\"}).");
-        lines.push("The gate is content-aware: novahiz-humanizer for prose; design files take no style gate rule.");
+        lines.push("The gate is content-aware: novahiz-humanizer, ui-slop-remover and ui-craft-rules are required only on frontend design tasks (R13).");
         lines.push("Config edited = opencode restart required (config read at import).");
         lines.push("Memory lives in project-memory/ under the project root (cwd): index.json + fixed-size slots (8000 chars / 200 lines) with compact → archive → new-slot rotation. Use the MCP memory_* tools to read and append.");
         enforcementBySession.set(input.sessionID, lines.join("\n"));
@@ -395,6 +550,29 @@ export const NovahizPlugin: Plugin = async ({ client }) => {
         await log("warn", `Gate error, denying the tool call as precaution: ${String(error)}`);
         throw new Error(`Novahiz gate blocked ${input.tool}: internal gate error. Set NOVAHIZ_GATE=off to disable.`);
       }
+    },
+
+    "tool.execute.after": async (input) => {
+      // Fail-open: mark major paths only; never break the tool result.
+      try {
+        const tool = input.tool.toLowerCase();
+        if (!["edit", "write", "patch", "apply_patch"].includes(tool)) return;
+        const args = (input.args ?? {}) as Record<string, unknown>;
+        const raw =
+          (typeof args.filePath === "string" && args.filePath) ||
+          (typeof args.file_path === "string" && args.file_path) ||
+          (typeof args.path === "string" && args.path) ||
+          "";
+        if (!raw) return;
+        const cwd = process.cwd();
+        const abs = resolve(cwd, raw);
+        const rel = relative(cwd, abs).replace(/\\/g, "/");
+        if (!rel || rel.startsWith("..")) return;
+        if (!isMajorPath(rel)) return;
+        markDirty(cwd, rel);
+      } catch {
+        // fail-open
+      }
     }
   };
 };

package/bin/novahiz.cmd

@@ -1,2 +1,2 @@
-@echo off
-node "%~dp0..\src\cli.ts" %*
+@echo off
+node "%~dp0..\src\cli.ts" %*