create-harness-vibe-coding 0.8.7 → 0.8.9

package/templates/common/Harness/scripts/wf-auto-update-prompt.mjs

@@ -0,0 +1,258 @@
+#!/usr/bin/env node
+/**
+ * wf-auto-update-prompt.mjs
+ *
+ * Lightweight hook helper for Claude Code, Codex, and OpenCode.
+ * It checks the installed Harness update plan and emits a prompt reminder only
+ * when an update is available. It never applies updates.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { spawnSync } from 'child_process';
+
+const DEFAULT_CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000;
+const DEFAULT_NOTICE_INTERVAL_MS = 60 * 60 * 1000;
+const args = process.argv.slice(2);
+const format = readFlagValue('--format') || 'plain';
+const force = args.includes('--force');
+const modeOnly = args.includes('--mode-only');
+const input = readStdinJson();
+const root = findRoot();
+
+function readFlagValue(flagName) {
+  const index = args.indexOf(flagName);
+  if (index === -1) return null;
+  const value = args[index + 1];
+  return value && !value.startsWith('--') ? value : null;
+}
+
+function readStdinJson() {
+  try {
+    if (process.stdin.isTTY) return {};
+    const raw = readFileSync(0, 'utf-8').trim();
+    return raw ? JSON.parse(raw) : {};
+  } catch {
+    return {};
+  }
+}
+
+function findRoot() {
+  const candidates = [
+    process.env.WF_ROOT,
+    input.cwd,
+    input.workspace,
+    process.cwd(),
+  ].filter(Boolean);
+
+  for (const candidate of candidates) {
+    const found = ascendToHarnessRoot(resolve(candidate));
+    if (found) return found;
+  }
+  return process.cwd();
+}
+
+function ascendToHarnessRoot(start) {
+  let current = start;
+  for (;;) {
+    if (existsSync(resolve(current, 'Harness', '.harness-version'))) return current;
+    const parent = dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+
+function runtimeDir() {
+  return resolve(root, 'Harness', '.runtime');
+}
+
+function cachePath() {
+  return resolve(runtimeDir(), 'update-check.json');
+}
+
+function modePath() {
+  return resolve(runtimeDir(), 'current-mode.json');
+}
+
+function readJsonFile(file, fallback) {
+  try {
+    return JSON.parse(readFileSync(file, 'utf-8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJsonFile(file, value) {
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, JSON.stringify(value, null, 2) + '\n', 'utf-8');
+}
+
+function readVersion() {
+  return readJsonFile(resolve(root, 'Harness', '.harness-version'), null);
+}
+
+function shouldSkipPrompt() {
+  const prompt = String(input.prompt || input.message || '');
+  return /\b\/?wf-update\b|\$wf-update\b/.test(prompt);
+}
+
+function intervalFromEnv(name, fallback) {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+}
+
+function runUpdateCheck() {
+  const script = resolve(root, 'Harness', 'scripts', 'wf-update-check.mjs');
+  if (!existsSync(script)) {
+    return { status: 'error', message: 'Harness/scripts/wf-update-check.mjs not found.' };
+  }
+  const result = spawnSync(process.execPath, [script, '--json'], {
+    cwd: root,
+    encoding: 'utf-8',
+    timeout: intervalFromEnv('WF_UPDATE_CHECK_TIMEOUT_MS', 30000),
+    env: process.env,
+  });
+
+  if (result.error) {
+    return { status: 'offline', message: result.error.message };
+  }
+
+  const stdout = (result.stdout || '').trim();
+  if (!stdout) {
+    return { status: 'error', message: `Update checker exited with no JSON output (${result.status ?? 'unknown'}).` };
+  }
+
+  try {
+    return JSON.parse(stdout);
+  } catch {
+    return { status: 'error', message: 'Update checker returned invalid JSON.' };
+  }
+}
+
+function isUpdateStatus(status) {
+  return status === 'update-available' || status === 'partial-update';
+}
+
+function buildMessage(update) {
+  const from = update.from || update.version || 'unknown';
+  const to = update.to || update.remote || 'unknown';
+  const parts = [
+    `Harness update available: ${from} -> ${to}.`,
+    `Before unrelated work, ask the user whether to run /wf-update.`,
+  ];
+  // Only include summary counts — never list individual conflict files in hook output
+  if (update.conflict > 0) {
+    parts.push(`${update.conflict} conflict file(s) will need agent/user merge decisions.`);
+  }
+  if ((update.updated > 0 || update.created > 0) && update.updated !== undefined) {
+    const safeCount = (update.updated || 0) + (update.created || 0);
+    parts.push(`${safeCount} safe file update(s) available.`);
+  }
+  // Max 2 lines total, never include plan details
+  return parts.slice(0, 2).join(' ');
+}
+
+function readModeLabel() {
+  const mode = readJsonFile(modePath(), null);
+  if (!mode || !mode.active || !mode.mode) return null;
+  return `${mode.mode} mode on`;
+}
+
+function emit(message, payload = {}) {
+  if (!message && !payload.modeLabel) return;
+
+  if (format === 'claude') {
+    const context = [message, payload.modeLabel].filter(Boolean).join('\n');
+    if (context) console.log(JSON.stringify({ additionalContext: context }));
+    return;
+  }
+
+  if (format === 'codex') {
+    const context = [message, payload.modeLabel].filter(Boolean).join('\n');
+    if (context) {
+      console.log(JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: input.hook_event_name || 'UserPromptSubmit',
+          additionalContext: context,
+        },
+      }));
+    }
+    return;
+  }
+
+  if (format === 'json') {
+    console.log(JSON.stringify({ message, ...payload }, null, 2));
+    return;
+  }
+
+  if (message) console.log(message);
+  if (payload.modeLabel) console.log(payload.modeLabel);
+}
+
+function main() {
+  if (!existsSync(resolve(root, 'Harness', '.harness-version'))) return;
+  const version = readVersion();
+  if (version?.autoCheck === false) return;
+
+  const modeLabel = readModeLabel();
+  if (modeOnly) {
+    emit('', { modeLabel, status: 'mode' });
+    return;
+  }
+
+  if (shouldSkipPrompt()) {
+    emit('', { modeLabel, status: 'skipped-update-command' });
+    return;
+  }
+
+  const now = Date.now();
+  const cache = readJsonFile(cachePath(), {});
+  const checkInterval = intervalFromEnv('WF_UPDATE_CHECK_INTERVAL_MS', DEFAULT_CHECK_INTERVAL_MS);
+  const noticeInterval = intervalFromEnv('WF_UPDATE_NOTICE_INTERVAL_MS', DEFAULT_NOTICE_INTERVAL_MS);
+
+  let update = cache.update;
+  const shouldCheck = force
+    || !cache.checkedAt
+    || now - Date.parse(cache.checkedAt) >= checkInterval;
+
+  if (shouldCheck) {
+    update = runUpdateCheck();
+    writeJsonFile(cachePath(), {
+      checkedAt: new Date(now).toISOString(),
+      noticedAt: cache.noticedAt || null,
+      update,
+    });
+  }
+
+  if (!isUpdateStatus(update?.status)) {
+    emit('', { modeLabel, status: update?.status || 'unknown' });
+    return;
+  }
+
+  const shouldNotice = force
+    || !cache.noticedAt
+    || now - Date.parse(cache.noticedAt) >= noticeInterval
+    || cache.update?.to !== update.to
+    || cache.update?.remote !== update.remote;
+
+  if (!shouldNotice) {
+    emit('', { modeLabel, status: update.status, suppressed: true });
+    return;
+  }
+
+  writeJsonFile(cachePath(), {
+    checkedAt: cache.checkedAt || new Date(now).toISOString(),
+    noticedAt: new Date(now).toISOString(),
+    update,
+  });
+
+  emit(buildMessage(update), { modeLabel, status: update.status, update });
+}
+
+try {
+  main();
+} catch {
+  // Hooks must fail open. A broken update reminder should never block work.
+}

package/templates/common/{scripts → Harness/scripts}/wf-remove.mjs

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 /**
- * wf-remove.mjs �?Safely remove Harness framework files.
+ * wf-remove.mjs �?Safely remove Harness framework files.
  *
  * Classifies all Harness-owned files into:
- *   SAFE     �?framework files matching stored checksums �?auto-remove
- *   MODIFIED �?framework files edited by user �?MUST confirm
- *   USER     �?user data files �?NEVER remove
+ *   SAFE     �?framework files matching stored checksums �?auto-remove
+ *   MODIFIED �?framework files edited by user �?MUST confirm
+ *   USER     �?user data files �?NEVER remove
  *
  * Usage:
  *   node Harness/scripts/wf-remove.mjs                    # dry-run: show plan
@@ -38,6 +38,8 @@ const HARNESS_PREFIXES = [
   '.claude/',
   '.agents/',
   '.codex/',
+  '.opencode/',
+  'opencode.json',
   'Harness/',
   'CLAUDE.md',
   'AGENTS.md',
@@ -45,7 +47,7 @@ const HARNESS_PREFIXES = [
   'tests/.gitkeep',
 ];
 
-/** Files the user owns �?NEVER remove. Consistent with wf-update-check PRESERVE_PATTERNS. */
+/** Files the user owns �?NEVER remove. Consistent with wf-update-check PRESERVE_PATTERNS. */
 const USER_DATA_PATTERNS = [
   /^Harness\/PROGRESS\.md$/,
   /^Harness\/tasks\//,
@@ -144,13 +146,18 @@ const BUILT_IN_SKILL_NAMES = [
 ];
 
 const KNOWN_FRAMEWORK_FILES = new Set([
-  ...BUILT_IN_AGENT_NAMES.map(name => `.claude/agents/${name}.md`),
+  ...BUILT_IN_AGENT_NAMES.flatMap(name => [
+    `.claude/agents/${name}.md`,
+    `.opencode/agents/${name}.md`,
+  ]),
   ...BUILT_IN_SKILL_NAMES.flatMap(name => [
     `.claude/skills/${name}/SKILL.md`,
     `.agents/skills/${name}/SKILL.md`,
   ]),
   '.claude/commands/wf-help.md',
+  '.opencode/commands/wf-help.md',
   '.claude/rules/ecc/common.md',
+  'opencode.json',
 ]);
 
 function isKnownFrameworkFile(file) {
@@ -185,6 +192,10 @@ const CLEANUP_DIRS = [
   '.agents/skills',
   '.agents',
   '.codex',
+  '.opencode/commands',
+  '.opencode/agents',
+  '.opencode/skills',
+  '.opencode',
   '.claude/rules/ecc',
   '.claude/rules',
   'Harness/scripts',
@@ -305,7 +316,7 @@ function removeEmptyDirs(startDir) {
 
 async function askUser(question) {
   if (!process.stdin.isTTY) {
-    console.log('   (non-interactive �?defaulting to KEEP)');
+    console.log('   (non-interactive �?defaulting to KEEP)');
     return 'k';
   }
   const rl = createInterface({ input: process.stdin, output: process.stdout });
@@ -378,9 +389,9 @@ async function main() {
   }
 
   // 2. Classify every file
-  const safe = [];     // SAFE �?matches checksum, auto-remove
-  const modified = []; // MODIFIED �?user edited, must confirm
-  const user = [];     // USER �?never remove
+  const safe = [];     // SAFE �?matches checksum, auto-remove
+  const modified = []; // MODIFIED �?user edited, must confirm
+  const user = [];     // USER �?never remove
   const skipped = [];  // File not on disk, traversal rejected, or framework-keep
   const purge = [];    // Explicitly requested Harness user-data removal
   skipped.push(...scanIssues);
@@ -402,13 +413,13 @@ async function main() {
         });
         continue;
       }
-      user.push({ file, reason: 'user data �?NEVER removed' });
+      user.push({ file, reason: 'user data �?NEVER removed' });
       continue;
     }
 
     // Only allow deletion of files under harness-owned prefixes
     if (!isHarnessOwned(canonical)) {
-      user.push({ file, reason: 'outside harness prefix �?NEVER removed' });
+      user.push({ file, reason: 'outside harness prefix �?NEVER removed' });
       continue;
     }
 
@@ -427,12 +438,18 @@ async function main() {
 
     if (!storedHash) {
       if (isKnownFrameworkFile(canonical)) {
-        safe.push({
-          file,
-          currentHash,
-          storedHash: currentHash,
-          reason: 'known framework file missing from legacy checksums',
-        });
+        if (canonical === 'opencode.json') {
+          // opencode.json without provenance — may pre-date Harness install.
+          // Only auto-remove when checksum proves Harness created it.
+          modified.push({ file, currentHash, storedHash: 'none', reason: 'not in checksums (may be pre-existing user config)' });
+        } else {
+          safe.push({
+            file,
+            currentHash,
+            storedHash: currentHash,
+            reason: 'known framework file missing from legacy checksums',
+          });
+        }
       } else {
         modified.push({ file, currentHash, storedHash: 'none', reason: 'not in checksums' });
       }
@@ -449,7 +466,7 @@ async function main() {
     const settingsHash = sha256File(settingsFile);
     const storedSettingsHash = storedChecksums['.claude/settings.json'];
     if (storedSettingsHash && settingsHash !== storedSettingsHash) {
-      // User modified settings �?move to modified
+      // User modified settings �?move to modified
       // Remove from safe if it was there
       const idx = safe.findIndex(s => s.file === '.claude/settings.json');
       if (idx >= 0) {
@@ -493,16 +510,16 @@ async function main() {
     return;
   }
 
-  console.log('\n🧹 WF-REMOVE �?Harness framework removal plan\n');
+  console.log('\n🧹 WF-REMOVE �?Harness framework removal plan\n');
 
   if (safe.length > 0) {
-    console.log(`�?SAFE (${safe.length} files �?auto-remove, unmodified framework):`);
-    for (const s of safe) console.log(`   �?${s.file}`);
+    console.log(`�?SAFE (${safe.length} files �?auto-remove, unmodified framework):`);
+    for (const s of safe) console.log(`   �?${s.file}`);
     console.log('');
   }
 
   if (modified.length > 0) {
-    console.log(`�?MODIFIED (${modified.length} files �?REQUIRE CONFIRMATION):`);
+    console.log(`�?MODIFIED (${modified.length} files �?REQUIRE CONFIRMATION):`);
     for (const m of modified) {
       console.log(`   ? ${m.file}  [${m.reason}]`);
     }
@@ -510,8 +527,8 @@ async function main() {
   }
 
   if (user.length > 0) {
-    console.log(`🔒 USER DATA (${user.length} files �?NEVER removed):`);
-    for (const u of user) console.log(`   �?${u.file}  [${u.reason}]`);
+    console.log(`🔒 USER DATA (${user.length} files �?NEVER removed):`);
+    for (const u of user) console.log(`   �?${u.file}  [${u.reason}]`);
     console.log('');
   }
 
@@ -528,17 +545,17 @@ async function main() {
     return;
   }
 
-  // 4. Apply �?remove SAFE files automatically (rehash before unlink)
+  // 4. Apply �?remove SAFE files automatically (rehash before unlink)
   let safeRemoved = 0;
   let safeFailed = 0;
   for (const s of safe) {
     const diskPath = safePath(s.file);
-    if (!diskPath) { console.error(`   �?Traversal rejected: ${s.file}`); safeFailed++; continue; }
+    if (!diskPath) { console.error(`   �?Traversal rejected: ${s.file}`); safeFailed++; continue; }
     if (!existsSync(diskPath)) continue;
     // Re-verify hash hasn't changed since classification
     const currentHash = sha256File(diskPath);
     if (currentHash !== s.storedHash) {
-      console.log(`   �?Skipped (modified since classification): ${s.file}`);
+      console.log(`   �?Skipped (modified since classification): ${s.file}`);
       safeFailed++;
       continue;
     }
@@ -546,13 +563,13 @@ async function main() {
       unlinkSync(diskPath);
       safeRemoved++;
     } catch (e) {
-      console.error(`   �?Failed to remove: ${s.file} �?${e.message}`);
+      console.error(`   �?Failed to remove: ${s.file} �?${e.message}`);
       safeFailed++;
     }
   }
-  console.log(`�?Removed ${safeRemoved} safe files.`);
+  console.log(`�?Removed ${safeRemoved} safe files.`);
 
-  // 5. Handle MODIFIED files �?prompt user
+  // 5. Handle MODIFIED files �?prompt user
   let modifiedRemoved = 0;
   let modifiedKept = 0;
   let modifiedFailed = 0;
@@ -572,7 +589,7 @@ async function main() {
     }
     if (yes) {
       // Non-interactive mode: skip all modified
-      console.log(`   �?Skipped (modified): ${m.file}`);
+      console.log(`   �?Skipped (modified): ${m.file}`);
       modifiedKept++;
       continue;
     }
@@ -584,17 +601,17 @@ async function main() {
     const answer = await askUser('   Choose [d/k]: ');
     if (answer === 'd' || answer === 'delete') {
       const diskPath = safePath(m.file);
-      if (!diskPath) { console.error(`   �?Traversal rejected: ${m.file}`); modifiedFailed++; continue; }
+      if (!diskPath) { console.error(`   �?Traversal rejected: ${m.file}`); modifiedFailed++; continue; }
       try {
         unlinkSync(diskPath);
-        console.log(`   �?Deleted: ${m.file}`);
+        console.log(`   �?Deleted: ${m.file}`);
         modifiedRemoved++;
       } catch (e) {
-        console.error(`   �?Failed: ${m.file} �?${e.message}`);
+        console.error(`   �?Failed: ${m.file} �?${e.message}`);
         modifiedFailed++;
       }
     } else {
-      console.log(`   �?Kept: ${m.file}`);
+      console.log(`   �?Kept: ${m.file}`);
       modifiedKept++;
     }
   }
@@ -655,7 +672,7 @@ async function main() {
       }
     } else if (!existsSync(harPath) || (existsSync(harPath) && readdirSync(harPath).filter(f => f !== '.harness-version').length === 0)) {
       unlinkSync(VERSION_FILE);
-      console.log('�?Removed .harness-version (Harness directory empty).');
+      console.log('�?Removed .harness-version (Harness directory empty).');
     }
   }
 
@@ -674,7 +691,7 @@ async function main() {
     if (pruned > 0) {
       versionData.checksums = checksums;
       writeFileSync(VERSION_FILE, JSON.stringify(versionData, null, 2) + '\n', 'utf-8');
-      console.log(`�?Pruned ${pruned} stale checksum(s) from .harness-version.`);
+      console.log(`�?Pruned ${pruned} stale checksum(s) from .harness-version.`);
     }
   }
 
@@ -688,7 +705,7 @@ async function main() {
         // Strip the harness section: everything from "## 1. Harness Binding" to the next "## "
         const cleaned = content.replace(/## 1\. Harness Binding[\s\S]*?(?=## 2\.)/, '');
         writeFileSync(claudePath, cleaned, 'utf-8');
-        console.log('�?Stripped Harness binding section from CLAUDE.md.');
+        console.log('�?Stripped Harness binding section from CLAUDE.md.');
       }
     }
   }