@noir-ai/create 1.17.0-beta.1 → 1.18.0-beta.1

package/dist/index.d.ts

@@ -239,13 +239,8 @@ interface WriteOutcome {
  *  Parent directories are NOT created here — the orchestrator does that once
  *  for the whole manifest so a missing dir is a single, attributable failure
  *  rather than N silent ones inside the writer.
- *
- *  `mode` applies to the temp file at creation and rides the rename onto the
- *  target, so an entry executed directly (the SessionStart hook runner) lands
- *  with its exec bit on a first write and a rewrite alike. As with core's
- *  `atomicWriteFile`, the requested bits are an upper bound (the process umask
- *  can narrow them) and Windows ignores them (ACL-based permissions). */
-declare function regenerate(absPath: string, content: string, mode?: number): WriteOutcome;
+ */
+declare function regenerate(absPath: string, content: string): WriteOutcome;
 /** Re-emit a managed region, delegating to core's `writeManagedRegion`.
  *  `regionText` MUST already include the begin/end markers (matches the shape
  *  `writeManagedRegion` expects and that `IGNORE_BLOCK`/`CONTEXT_BLOCK`
@@ -581,11 +576,11 @@ declare function mergeThreeWay(base: string, ours: string, theirs: string, style
  *    `result.conflicts` so the caller (doctor/CI) can fail loudly with a
  *    reviewable artifact rather than hang on a prompt.
  *
- * The registry ({@link MIGRATIONS}) carries four entries: the synthetic
- * `1.0.0 → 1.0.0` smoke test that exercises the runner end-to-end, and three
- * real version-to-version migrations, `1.0.0 → 1.1.0`, `1.1.0 → 1.2.0` and
- * `1.2.0 → 1.3.0`. The synthetic one is the copy-pasteable template for the
- * next contributor.
+ * The registry ({@link MIGRATIONS}) carries five entries: the synthetic
+ * `1.0.0 → 1.0.0` smoke test that exercises the runner end-to-end, and four
+ * real version-to-version migrations, `1.0.0 → 1.1.0`, `1.1.0 → 1.2.0`,
+ * `1.2.0 → 1.3.0` and `1.3.0 → 1.4.0`. The synthetic one is the copy-pasteable
+ * template for the next contributor.
  */
 interface MigrationContext {
     /** Absolute repo root the migration operates on. */
@@ -888,9 +883,9 @@ declare function scaffold(opts: ScaffoldOptions): Promise<ScaffoldResult>;
 /** The scaffold version this build of @noir-ai/create ships. Bumped atomically
  *  whenever a manifest entry, template, or migration changes shape. 1.3.0 adds
  *  the migration that points a joined repo's MCP entry back at the workspace
- *  bridge — a repair only the upgrade path can perform, so projects stamped
- *  1.2.0 and below need a window that starts at their version to reach it. */
-declare const CURRENT_SCAFFOLD_VERSION = "1.3.0";
+ *  bridge; 1.4.0 adds the migration that moves the SessionStart hook command off
+ *  the `.mjs` runner and onto `noir hook` (see migrations/index.ts). */
+declare const CURRENT_SCAFFOLD_VERSION = "1.4.0";
 /** Path to the stamp file under `root`. Exposed for tests + doctor. */
 declare function scaffoldVersionPath(root: string): string;
 /** Read the applied scaffold version, or `null` if the stamp is absent/unparseable.

package/dist/index.js

@@ -316,7 +316,7 @@ function buildHostArtifacts(adapter, ctx) {
     });
   }
   if (host === "claude") {
-    const HOOK_DEDUP = "noir-session-start";
+    const HOOK_DEDUP = " hook";
     const hookEntry = {
       hooks: {
         SessionStart: [
@@ -324,7 +324,7 @@ function buildHostArtifacts(adapter, ctx) {
             hooks: [
               {
                 type: "command",
-                command: `"${ctx.root}/.noir/hooks/noir-session-start.mjs"`
+                command: `"${ctx.command}" hook`
               }
             ]
           }
@@ -334,7 +334,7 @@ function buildHostArtifacts(adapter, ctx) {
             hooks: [
               {
                 type: "command",
-                command: `"${ctx.root}/.noir/hooks/noir-session-start.mjs"`
+                command: `"${ctx.command}" hook`
               }
             ]
           }
@@ -349,14 +349,6 @@ function buildHostArtifacts(adapter, ctx) {
       dedupSubstring: HOOK_DEDUP,
       description: "SessionStart + SubagentStart hook entry (user-owned, written once)"
     });
-    entries.push({
-      path: ".noir/hooks/noir-session-start.mjs",
-      mode: "regenerate",
-      fileMode: 493,
-      host,
-      content: SESSION_START_HOOK_SCRIPT,
-      description: "SessionStart hook runner (Noir-owned, re-emitted)"
-    });
     entries.push({
       path: ".noir/router.md",
       mode: "managedBlock",
@@ -377,40 +369,6 @@ function buildHostArtifacts(adapter, ctx) {
   }
   return entries;
 }
-var SESSION_START_HOOK_SCRIPT = `#!/usr/bin/env node
-// Noir SessionStart hook \u2014 injects the skill router contract + anti-slop ruleset
-// at session start. The mutable contract lives in .noir/router.md (a Noir
-// managed block, so user edits outside the markers survive noir sync) and the
-// ruleset in .noir/rules/anti-slop.md (regenerated). This script is a pure runner.
-import { readFileSync, existsSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const ROOT = join(HERE, '..', '..');
-const ROUTER = join(ROOT, '.noir', 'router.md');
-const RULES = join(ROOT, '.noir', 'rules', 'anti-slop.md');
-
-function readIfPresent(path) {
-  if (!existsSync(path)) return '';
-  return readFileSync(path, 'utf8').trim();
-}
-
-function main() {
-  const parts = [readIfPresent(ROUTER), readIfPresent(RULES)].filter((part) => part !== '');
-  if (parts.length === 0) {
-    // Neither contract present (project not initialized / both removed) \u2014 silent.
-    process.stdout.write(JSON.stringify({ hookSpecificOutput: {} }));
-    process.exit(0);
-  }
-  const context = parts.join('\\n\\n');
-  process.stdout.write(
-    JSON.stringify({ hookSpecificOutput: { additionalContext: context } }),
-  );
-}
-
-main();
-`;
 function hostRel(abs, root) {
   const rel = relative(root, abs);
   if (rel.length === 0 || rel.startsWith("..") || rel.startsWith("/")) {
@@ -567,7 +525,7 @@ function mergeThreeWay(base, ours, theirs, style = "minimal") {
 }
 
 // src/migrations/index.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync4, readdirSync, readFileSync as readFileSync4, rmdirSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
 import { join as join5, relative as relative2, sep } from "path";
 import { mcpConfigPathFor, noirStdioArgs, TRANSPORT_KEYS } from "@noir-ai/adapters";
 import {
@@ -829,7 +787,7 @@ import {
 import { basename, dirname as dirname3, join as join4 } from "path";
 import { atomicWriteFile, stripManagedBlock, writeManagedRegion } from "@noir-ai/core";
 import { ensureOwnerOnly } from "@noir-ai/core";
-function regenerate(absPath, content, mode) {
+function regenerate(absPath, content) {
   const dir = dirname3(absPath);
   const tmp = join4(
     dir,
@@ -837,7 +795,7 @@ function regenerate(absPath, content, mode) {
   );
   let fd;
   try {
-    fd = openSync(tmp, "w", mode);
+    fd = openSync(tmp, "w");
     writeSync(fd, content, 0, "utf8");
     closeSync(fd);
     fd = void 0;
@@ -949,6 +907,17 @@ function mergeJson(absPath, patch, dedupSubstring) {
   regenerate(absPath, content);
   return { path: absPath, mode: "mergeJson", written: true };
 }
+function entryHasCommand(entry, marker) {
+  if (typeof entry !== "object" || entry === null) return false;
+  const obj = entry;
+  if (typeof obj.command === "string" && obj.command.includes(marker)) return true;
+  if (!Array.isArray(obj.hooks)) return false;
+  return obj.hooks.some((h) => {
+    if (typeof h !== "object" || h === null) return false;
+    const command = h.command;
+    return typeof command === "string" && command.includes(marker);
+  });
+}
 function deepMergePreservingHooks(existing, patch, dedupSubstring) {
   const out = { ...existing };
   for (const [key, value] of Object.entries(patch)) {
@@ -958,9 +927,7 @@ function deepMergePreservingHooks(existing, patch, dedupSubstring) {
       for (const [event, entries] of Object.entries(value)) {
         const existingEntries = Array.isArray(mergedHooks[event]) ? mergedHooks[event] : [];
         const patchEntries = Array.isArray(entries) ? entries : [];
-        const alreadyRegistered = dedupSubstring !== void 0 && existingEntries.some(
-          (x) => x?.command?.includes(dedupSubstring) ?? false
-        );
+        const alreadyRegistered = dedupSubstring !== void 0 && existingEntries.some((x) => entryHasCommand(x, dedupSubstring));
         const toAdd = alreadyRegistered ? [] : patchEntries;
         mergedHooks[event] = [...existingEntries, ...toAdd];
       }
@@ -1234,11 +1201,98 @@ var workspaceBridge = {
     return result;
   }
 };
+var OLD_HOOK_MARKER = "noir-session-start";
+var hookCommand = {
+  from: "1.3.0",
+  to: "1.4.0",
+  description: "route the SessionStart hook through `noir hook` (drop the .mjs runner)",
+  run: (ctx) => {
+    const result = { changed: [], conflicts: [], notes: [] };
+    const settingsRel = ".claude/settings.local.json";
+    const settingsPath = join5(ctx.root, ".claude", "settings.local.json");
+    if (existsSync4(settingsPath)) {
+      let settings;
+      try {
+        settings = JSON.parse(readFileSync4(settingsPath, "utf8"));
+      } catch (err) {
+        result.conflicts.push(settingsRel);
+        result.notes.push(
+          `${settingsRel}: unreadable (${errorMessage(err)}) \u2014 command left untouched`
+        );
+        settings = {};
+      }
+      let rewritten = false;
+      const hooks = settings.hooks;
+      if (typeof hooks === "object" && hooks !== null && !Array.isArray(hooks)) {
+        for (const eventEntries of Object.values(hooks)) {
+          if (!Array.isArray(eventEntries)) continue;
+          for (const group of eventEntries) {
+            if (typeof group !== "object" || group === null) continue;
+            const inner = group.hooks;
+            if (!Array.isArray(inner)) continue;
+            for (const entry of inner) {
+              if (typeof entry !== "object" || entry === null) continue;
+              const hookObj = entry;
+              if (typeof hookObj.command === "string" && hookObj.command.includes(OLD_HOOK_MARKER)) {
+                hookObj.command = `"${resolveNoirCommand()}" hook`;
+                rewritten = true;
+              }
+            }
+          }
+        }
+      }
+      if (!rewritten) {
+        result.notes.push(`${settingsRel}: no .mjs hook command to migrate`);
+      } else if (ctx.dryRun) {
+        result.changed.push(settingsRel);
+        result.notes.push(`${settingsRel}: would route the hook through \`noir hook\``);
+      } else {
+        try {
+          atomicWriteFile2(settingsPath, `${JSON.stringify(settings, null, 2)}
+`);
+          result.changed.push(settingsRel);
+          result.notes.push(`${settingsRel}: hook now routes through \`noir hook\``);
+        } catch (err) {
+          result.conflicts.push(settingsRel);
+          result.notes.push(`${settingsRel}: write failed (${errorMessage(err)}) \u2014 left untouched`);
+        }
+      }
+    } else {
+      result.notes.push(`${settingsRel}: absent \u2014 nothing to migrate`);
+    }
+    const runnerRel = ".noir/hooks/noir-session-start.mjs";
+    const runnerPath = join5(ctx.root, ".noir", "hooks", "noir-session-start.mjs");
+    if (!existsSync4(runnerPath)) {
+      return result;
+    }
+    if (ctx.dryRun) {
+      result.changed.push(runnerRel);
+      result.notes.push(`${runnerRel}: would remove the orphaned runner`);
+      return result;
+    }
+    try {
+      rmSync2(runnerPath, { force: true });
+    } catch (err) {
+      result.conflicts.push(runnerRel);
+      result.notes.push(`${runnerRel}: remove failed (${errorMessage(err)})`);
+      return result;
+    }
+    result.changed.push(runnerRel);
+    result.notes.push(`${runnerRel}: removed (orphaned runner)`);
+    const hooksDir = join5(ctx.root, ".noir", "hooks");
+    try {
+      if (readdirSync(hooksDir).length === 0) rmdirSync(hooksDir);
+    } catch {
+    }
+    return result;
+  }
+};
 var MIGRATIONS = [
   synthetic,
   envPointer,
   envTemplates,
-  workspaceBridge
+  workspaceBridge,
+  hookCommand
 ];
 function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
@@ -1258,15 +1312,7 @@ function applyWithConflict(ours, theirs, path) {
 }
 
 // src/scaffold.ts
-import {
-  chmodSync,
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync3,
-  readFileSync as readFileSync7,
-  renameSync as renameSync2,
-  rmSync as rmSync2,
-  statSync
-} from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync7, renameSync as renameSync2, rmSync as rmSync3 } from "fs";
 import { basename as basename2, dirname as dirname5, join as join8 } from "path";
 import {
   createProjectId,
@@ -1282,7 +1328,7 @@ import {
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync5 } from "fs";
 import { dirname as dirname4, join as join6 } from "path";
 import { NOIR_DIR as NOIR_DIR2 } from "@noir-ai/core";
-var CURRENT_SCAFFOLD_VERSION = "1.3.0";
+var CURRENT_SCAFFOLD_VERSION = "1.4.0";
 var PREFIX = "noir-scaffold=";
 function scaffoldVersionPath(root) {
   return join6(root, NOIR_DIR2, "scaffold-version");
@@ -1311,7 +1357,7 @@ function writeScaffoldVersion(root, version) {
 }
 
 // src/stack-detect.ts
-import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
 import { join as join7 } from "path";
 var NODE_FRAMEWORKS = [
   ["next", "next"],
@@ -1461,7 +1507,7 @@ function detectStack(root) {
   const cursorRulesDir = join7(root, ".cursor", "rules");
   try {
     if (existsSync5(cursorRulesDir)) {
-      const entries = readdirSync(cursorRulesDir);
+      const entries = readdirSync2(cursorRulesDir);
       for (const e of entries) {
         if (e.endsWith(".md"))
           existingAiFiles.push({ path: `.cursor/rules/${e}`, kind: "cursor-rules" });
@@ -1542,7 +1588,7 @@ async function scaffold(opts) {
   const idFile = readProjectIdFile(opts.root);
   const projectId = resolveProjectId(opts, idFile);
   if (!opts.dryRun && idFile.state === "corrupt") {
-    rmSync2(paths2.projectId(opts.root), { force: true });
+    rmSync3(paths2.projectId(opts.root), { force: true });
   }
   const fromVersion = readScaffoldVersion(opts.root);
   const stack = detectStack(opts.root);
@@ -1715,8 +1761,7 @@ async function scaffold(opts) {
       if (entry.mode === "regenerate") {
         const out = await writeWithConflict(abs, entry.path, body, opts, {
           memory: conflictMemory,
-          record: recordConflict,
-          mode: entry.fileMode
+          record: recordConflict
         });
         written.push(...out.written);
         skipped.push(...out.skipped);
@@ -1931,14 +1976,10 @@ async function writeWithConflict(abs, relPath, proposed, opts, internals) {
     existing = void 0;
   }
   if (existing === void 0) {
-    regenerate(abs, proposed, internals.mode);
+    regenerate(abs, proposed);
     return { written: [relPath], skipped: [], identical: [] };
   }
   if (existing === proposed) {
-    if (internals.mode !== void 0 && (statSync(abs).mode & 511) !== internals.mode) {
-      chmodSync(abs, internals.mode);
-      return { written: [relPath], skipped: [], identical: [] };
-    }
     return { written: [], skipped: [], identical: [relPath] };
   }
   const MODE = internals.artifactClass ?? "regenerate";
@@ -1960,21 +2001,21 @@ async function writeWithConflict(abs, relPath, proposed, opts, internals) {
   internals.record(relPath, MODE, existing, proposed, resolution, sim);
   switch (resolution) {
     case "replace":
-      regenerate(abs, proposed, internals.mode);
+      regenerate(abs, proposed);
       return { written: [relPath], skipped: [], identical: [] };
     case "merge": {
-      regenerate(abs, proposed, internals.mode);
+      regenerate(abs, proposed);
       return { written: [relPath], skipped: [], identical: [] };
     }
     case "rename": {
       const aside = uniqueAside(abs, relPath, ".local");
       renameSync2(abs, aside.abs);
-      regenerate(abs, proposed, internals.mode);
+      regenerate(abs, proposed);
       return { written: [relPath], skipped: [aside.rel], identical: [] };
     }
     case "duplicate": {
       const aside = uniqueAside(abs, relPath, ".noir");
-      regenerate(aside.abs, proposed, internals.mode);
+      regenerate(aside.abs, proposed);
       return { written: [aside.rel], skipped: [relPath], identical: [] };
     }
     case "preserve":
@@ -2016,7 +2057,7 @@ function healLegacyNoirMd(absPath) {
     return;
   }
   if (/<!-- noir:[a-z]+ begin -->/.test(content)) return;
-  rmSync2(absPath, { force: true });
+  rmSync3(absPath, { force: true });
 }
 function renderEntry(entry, vars) {
   if (entry.template !== void 0) {