@hanzlaa/rcode 2.1.0

package/rihal/bin/lib/roadmap.cjs

@@ -0,0 +1,256 @@
+/**
+ * Roadmap — Rihal ROADMAP.md parsing and mutation helpers.
+ *
+ * Self-contained (stdlib only). Matches GSD output shapes for the subset of
+ * commands that Rihal workflows currently invoke: get-phase, list-phases,
+ * update-plan-progress, and clear.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+function escapeRegex(s) { return String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); }
+
+function roadmapPathFor(projectRoot) {
+  return path.join(projectRoot, '.planning', 'ROADMAP.md');
+}
+
+/**
+ * Extract all phase sections. Each returned entry includes:
+ *   number, name, goal, section (raw markdown slice), headerIndex, sectionEnd
+ */
+function extractPhases(content) {
+  const phasePattern = /#{2,4}\s*Phase\s+(\d+[A-Z]?(?:\.\d+)*)\s*:\s*([^\n]+)/gi;
+  const hits = [];
+  let m;
+  while ((m = phasePattern.exec(content)) !== null) {
+    hits.push({ number: m[1], name: m[2].trim(), headerIndex: m.index });
+  }
+  const phases = [];
+  for (let i = 0; i < hits.length; i++) {
+    const h = hits[i];
+    const end = i + 1 < hits.length ? hits[i + 1].headerIndex : content.length;
+    const section = content.slice(h.headerIndex, end).trim();
+    const goalMatch = section.match(/\*\*Goal(?::\*\*|\*\*:)\s*([^\n]+)/i);
+    const goal = goalMatch ? goalMatch[1].trim() : null;
+    phases.push({
+      number: h.number,
+      name: h.name,
+      goal,
+      section,
+      headerIndex: h.headerIndex,
+      sectionEnd: end,
+    });
+  }
+  return phases;
+}
+
+function parseRequirements(section) {
+  // **Requirements** or **Requirements:** followed by numbered or bulleted list
+  const match = section.match(/\*\*Requirements(?::\*\*|\*\*:)[^\n]*\n((?:\s*(?:\d+\.|[-*])\s+[^\n]+\n?)+)/i);
+  if (!match) return [];
+  return match[1].split('\n')
+    .map((l) => l.replace(/^\s*(?:\d+\.|[-*])\s+/, '').trim())
+    .filter(Boolean);
+}
+
+function parseSuccessCriteria(section) {
+  const match = section.match(/\*\*Success Criteria\*\*[^\n]*:\s*\n((?:\s*(?:\d+\.|[-*])\s+[^\n]+\n?)+)/i);
+  if (!match) return [];
+  return match[1].split('\n')
+    .map((l) => l.replace(/^\s*(?:\d+\.|[-*])\s+/, '').trim())
+    .filter(Boolean);
+}
+
+function parsePlans(section) {
+  // Match a table of plans or checklist of plan IDs. Return array of
+  // { id, title, status } best-effort. Recognises conventional-commits style
+  // rows: "| NN-MM | title | status |" or "- [ ] NN-MM title".
+  const plans = [];
+  // Table rows
+  const tableRe = /^\|\s*(\d+-\d+)\s*\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|/gm;
+  let m;
+  while ((m = tableRe.exec(section)) !== null) {
+    plans.push({ id: m[1], title: m[2].trim(), status: m[3].trim().toLowerCase() });
+  }
+  if (plans.length > 0) return plans;
+  // Checklist fallback
+  const checkRe = /-\s*\[([ x])\]\s*(\d+-\d+)[:\s]+([^\n]+)/g;
+  while ((m = checkRe.exec(section)) !== null) {
+    plans.push({
+      id: m[2],
+      title: m[3].trim(),
+      status: m[1] === 'x' ? 'completed' : 'pending',
+    });
+  }
+  return plans;
+}
+
+function phaseStatus(section) {
+  // Look at the header line for "(completed ...)" or "(in progress)" hints.
+  const header = section.split('\n', 1)[0] || '';
+  if (/completed/i.test(header)) return 'complete';
+  const checkboxMatch = section.match(/-\s*\[(x| )\]\s*.*Phase\s+/i);
+  if (checkboxMatch && checkboxMatch[1] === 'x') return 'complete';
+  if (/\*\*Plans:\*\*[^\n]*plans complete/i.test(section)) return 'complete';
+  if (/in progress/i.test(section)) return 'in_progress';
+  return 'planned';
+}
+
+/**
+ * roadmap get-phase <N> [--pick section]
+ * Returns JSON or raw section markdown.
+ */
+function cmdGetPhase(projectRoot, phaseNum, opts = {}) {
+  const rp = roadmapPathFor(projectRoot);
+  if (!fs.existsSync(rp)) {
+    return { found: false, error: 'ROADMAP.md not found', phase_number: phaseNum };
+  }
+  const content = fs.readFileSync(rp, 'utf8');
+  const phases = extractPhases(content);
+  const match = phases.find((p) => p.number === String(phaseNum));
+  if (!match) return { found: false, phase_number: phaseNum };
+
+  if (opts.pick === 'section') {
+    return { __raw: match.section };
+  }
+
+  return {
+    found: true,
+    phase_number: match.number,
+    name: match.name,
+    goal: match.goal,
+    requirements: parseRequirements(match.section),
+    success_criteria: parseSuccessCriteria(match.section),
+    plans: parsePlans(match.section),
+  };
+}
+
+function cmdListPhases(projectRoot) {
+  const rp = roadmapPathFor(projectRoot);
+  if (!fs.existsSync(rp)) return [];
+  const content = fs.readFileSync(rp, 'utf8');
+  return extractPhases(content).map((p) => ({
+    number: p.number,
+    name: p.name,
+    status: phaseStatus(p.section),
+  }));
+}
+
+/**
+ * roadmap update-plan-progress <phase> <plan-id> <status>
+ * Atomically rewrites the plan status in ROADMAP.md.
+ */
+function cmdUpdatePlanProgress(projectRoot, phaseNum, planId, status) {
+  if (!phaseNum || !planId || !status) {
+    throw new Error('Usage: roadmap update-plan-progress <phase> <plan-id> <status>');
+  }
+  const rp = roadmapPathFor(projectRoot);
+  if (!fs.existsSync(rp)) {
+    return { updated: false, error: 'ROADMAP.md not found' };
+  }
+  const content = fs.readFileSync(rp, 'utf8');
+  const phases = extractPhases(content);
+  const phase = phases.find((p) => p.number === String(phaseNum));
+  if (!phase) return { updated: false, error: `phase ${phaseNum} not found` };
+
+  const planEscaped = escapeRegex(planId);
+  const section = content.slice(phase.headerIndex, phase.sectionEnd);
+
+  let previousStatus = null;
+  let newSection = section;
+
+  // Try table row first: "| id | title | old-status |"
+  const tableRowRe = new RegExp(`^(\\|\\s*${planEscaped}\\s*\\|[^\\n]*\\|\\s*)([^|\\n]+?)(\\s*\\|)`, 'm');
+  const tMatch = section.match(tableRowRe);
+  if (tMatch) {
+    previousStatus = tMatch[2].trim();
+    newSection = section.replace(tableRowRe, (_, a, _old, c) => `${a}${status.padEnd(Math.max(status.length, _old.length))}${c}`);
+  } else {
+    // Checklist: "- [ ] planId: ..." or "- [x] planId"
+    const mark = /completed|complete|done/i.test(status) ? 'x' : ' ';
+    const checkRe = new RegExp(`(-\\s*\\[)([ x])(\\]\\s*(?:\\*\\*)?${planEscaped})`, 'i');
+    const cMatch = section.match(checkRe);
+    if (cMatch) {
+      previousStatus = cMatch[2] === 'x' ? 'completed' : 'pending';
+      newSection = section.replace(checkRe, `$1${mark}$3`);
+    } else {
+      return { updated: false, error: `plan ${planId} not found in phase ${phaseNum}` };
+    }
+  }
+
+  const newContent = content.slice(0, phase.headerIndex) + newSection + content.slice(phase.sectionEnd);
+  const tmp = rp + '.tmp';
+  fs.writeFileSync(tmp, newContent, 'utf8');
+  fs.renameSync(tmp, rp);
+
+  return {
+    updated: true,
+    phase: phaseNum,
+    plan: planId,
+    status,
+    previous_status: previousStatus,
+  };
+}
+
+/**
+ * roadmap clear — archive and scaffold.
+ */
+function cmdClear(projectRoot) {
+  const rp = roadmapPathFor(projectRoot);
+  // Derive current version from config.yaml or default v1.0
+  const configPath = path.join(projectRoot, '.rihal', 'config.yaml');
+  let version = 'v1.0';
+  if (fs.existsSync(configPath)) {
+    const text = fs.readFileSync(configPath, 'utf8');
+    const m = text.match(/^\s*version:\s*"?([^"\n]+)"?/m);
+    if (m) version = m[1].trim().startsWith('v') ? m[1].trim() : 'v' + m[1].trim();
+  }
+  const archiveDir = path.join(projectRoot, '.planning', 'archive', version);
+  fs.mkdirSync(archiveDir, { recursive: true });
+
+  let archived = null;
+  if (fs.existsSync(rp)) {
+    archived = path.join(archiveDir, 'ROADMAP.md');
+    fs.renameSync(rp, archived);
+  }
+
+  const scaffold = `# Roadmap\n\n_Reset on ${new Date().toISOString()}. Previous roadmap archived to \`.planning/archive/${version}/ROADMAP.md\`._\n\n## Phases\n\n<!-- Add phases here with the format: ### Phase N: Name -->\n`;
+  fs.mkdirSync(path.dirname(rp), { recursive: true });
+  fs.writeFileSync(rp, scaffold, 'utf8');
+
+  return { cleared: true, archived, version, roadmap: rp };
+}
+
+function dispatch(projectRoot, subArgs) {
+  const sub = subArgs[0];
+  const rest = subArgs.slice(1);
+  switch (sub) {
+    case 'get-phase': {
+      const phaseNum = rest[0];
+      if (!phaseNum) throw new Error('Usage: roadmap get-phase <N> [--pick section]');
+      // Parse --pick
+      let pick = null;
+      for (let i = 1; i < rest.length; i++) {
+        if (rest[i] === '--pick') { pick = rest[i + 1]; i++; }
+      }
+      return cmdGetPhase(projectRoot, phaseNum, { pick });
+    }
+    case 'list-phases':
+      return cmdListPhases(projectRoot);
+    case 'update-plan-progress':
+      return cmdUpdatePlanProgress(projectRoot, rest[0], rest[1], rest[2]);
+    case 'clear':
+      return cmdClear(projectRoot);
+    default:
+      throw new Error(`Unknown roadmap subcommand: ${sub}. Valid: get-phase, list-phases, update-plan-progress, clear`);
+  }
+}
+
+module.exports = {
+  dispatch,
+  cmdGetPhase,
+  cmdListPhases,
+  cmdUpdatePlanProgress,
+  cmdClear,
+};

package/rihal/bin/lib/verify.cjs

@@ -0,0 +1,118 @@
+/**
+ * Verify — schema drift detection.
+ *
+ * Scans git commits whose subject matches the NNN- prefix for the supplied
+ * phase. For each commit that touches schema.prisma (or *.sql), we check
+ * whether prisma/migrations/ gained a new directory in the same or a later
+ * commit on the same branch. Missing migration directories → drift.
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+
+function git(args, cwd) {
+  try {
+    return execSync(`git ${args}`, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+  } catch (e) {
+    return '';
+  }
+}
+
+function commitsForPhase(projectRoot, phaseNum) {
+  // Look for commit subjects starting with NN- or NNN- matching the phase.
+  const log = git(`log --pretty=format:%H%x09%s`, projectRoot);
+  if (!log) return [];
+  const prefix = String(phaseNum).padStart(2, '0');
+  const re = new RegExp(`(^|[^0-9])${prefix}-\\d+`);
+  const commits = [];
+  for (const line of log.split('\n')) {
+    const [hash, ...rest] = line.split('\t');
+    const subject = rest.join('\t');
+    if (re.test(subject)) commits.push({ hash, subject });
+  }
+  return commits.reverse(); // oldest-first
+}
+
+function filesChanged(projectRoot, hash) {
+  const out = git(`show --name-only --pretty=format: ${hash}`, projectRoot);
+  return out.split('\n').map((l) => l.trim()).filter(Boolean);
+}
+
+function migrationsAddedIn(projectRoot, hash) {
+  // List added files under prisma/migrations/ for this commit, then extract
+  // unique migration directory names.
+  const out = git(`show --name-status --pretty=format: ${hash}`, projectRoot);
+  const dirs = new Set();
+  for (const line of out.split('\n')) {
+    const parts = line.split(/\s+/);
+    const status = parts[0];
+    const file = parts[parts.length - 1];
+    if (!file) continue;
+    if (status.startsWith('A') && file.startsWith('prisma/migrations/')) {
+      const seg = file.split('/')[2];
+      if (seg) dirs.add(seg);
+    }
+  }
+  return [...dirs];
+}
+
+function cmdSchemaDrift(projectRoot, phaseNum, opts = {}) {
+  if (!phaseNum) throw new Error('Usage: verify schema-drift <phase> [--block]');
+  const commits = commitsForPhase(projectRoot, phaseNum);
+
+  const driftFiles = [];
+  const missingMigrations = [];
+  let migrationsAvailable = new Set();
+
+  // First pass: collect all migration dirs that exist across all phase commits
+  // plus any that exist on disk currently.
+  for (const c of commits) {
+    for (const d of migrationsAddedIn(projectRoot, c.hash)) migrationsAvailable.add(d);
+  }
+
+  for (const c of commits) {
+    const files = filesChanged(projectRoot, c.hash);
+    const schemaTouched = files.filter((f) => f === 'schema.prisma' || f.endsWith('/schema.prisma') || f.endsWith('.sql'));
+    if (schemaTouched.length === 0) continue;
+
+    // Any migration added in this commit OR any later phase commit?
+    const added = migrationsAddedIn(projectRoot, c.hash);
+    const laterIdx = commits.findIndex((x) => x.hash === c.hash);
+    let laterAdded = [...added];
+    for (let i = laterIdx + 1; i < commits.length; i++) {
+      laterAdded.push(...migrationsAddedIn(projectRoot, commits[i].hash));
+    }
+    if (laterAdded.length === 0) {
+      for (const f of schemaTouched) {
+        driftFiles.push({ commit: c.hash.slice(0, 10), file: f, subject: c.subject });
+      }
+      missingMigrations.push({ commit: c.hash.slice(0, 10), subject: c.subject });
+    }
+  }
+
+  const driftDetected = driftFiles.length > 0;
+  return {
+    drift_detected: driftDetected,
+    blocking: Boolean(opts.block) && driftDetected,
+    drift_files: driftFiles,
+    missing_migrations: missingMigrations,
+    commits_scanned: commits.length,
+    phase: String(phaseNum),
+  };
+}
+
+function dispatch(projectRoot, subArgs) {
+  const sub = subArgs[0];
+  const rest = subArgs.slice(1);
+  switch (sub) {
+    case 'schema-drift': {
+      const phase = rest[0];
+      const block = rest.includes('--block');
+      return cmdSchemaDrift(projectRoot, phase, { block });
+    }
+    default:
+      throw new Error(`Unknown verify subcommand: ${sub}. Valid: schema-drift`);
+  }
+}
+
+module.exports = { dispatch, cmdSchemaDrift };

package/rihal/bin/rihal-hooks.cjs

@@ -0,0 +1,204 @@
+#!/usr/bin/env node
+/**
+ * rihal-hooks.cjs — opt-in hook runners for edit/workflow/commit guardrails.
+ *
+ * Subcommands:
+ *   pre-edit    — verify file was Read before Edit/Write (exit 2 if not)
+ *   pre-workflow — soft warning for rihal:* commands with suspicious args
+ *   post-commit — verify commit format and no forbidden patterns
+ *
+ * All subcommands read stdin JSON from the hook execution context.
+ * Pure Node stdlib. No external dependencies.
+ */
+
+const fs = require('fs');
+
+/**
+ * Read and parse stdin JSON.
+ */
+function readInputJson() {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => { data += chunk; });
+    process.stdin.on('end', () => {
+      try {
+        resolve(JSON.parse(data));
+      } catch (e) {
+        reject(new Error(`Failed to parse stdin JSON: ${e.message}`));
+      }
+    });
+    process.stdin.on('error', reject);
+  });
+}
+
+/**
+ * pre-edit: Verify that the file being edited was Read() first in this session.
+ * Block with exit 2 if not.
+ */
+async function preEdit() {
+  try {
+    const input = await readInputJson();
+    // Handle both harness schema (input.tool_input.X) and legacy schema (input.X)
+    const filePath = input.tool_input?.file_path || input.file_path;
+    const sessionReads = input.tool_input?.reads_in_session || input.reads_in_session || [];
+
+    if (!filePath) {
+      console.error('ERROR: No file_path in hook input');
+      process.exit(1);
+    }
+
+    if (!sessionReads.includes(filePath)) {
+      console.error(`⚠ READ-BEFORE-EDIT: Read ${filePath} before editing. (Advisory — session-read tracking not yet implemented)`);
+      process.exit(0);
+    }
+
+    process.exit(0);
+  } catch (err) {
+    console.error(`Hook error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * pre-workflow: Soft warning for rihal:* commands with suspicious args.
+ * Does not block (exit 0), but prints warning.
+ */
+async function preWorkflow() {
+  try {
+    const input = await readInputJson();
+    const command = input.command || '';
+    const args = input.args || '';
+
+    // Only check rihal:* commands
+    if (!command.startsWith('rihal:')) {
+      process.exit(0);
+    }
+
+    // Heuristics for suspicious args:
+    // - Planning command + question sounds like a decision (contains "should", "do we", "will", etc.)
+    // - Args look like they might be file paths instead of proper question
+    const suspiciousPatterns = [
+      /\bshould\b/i,
+      /\bdo we\b/i,
+      /\bwill\b/i,
+      /^\/[a-z]/i,
+      /\s\.[\/\\]/,
+    ];
+
+    let hasSuspiciousPattern = false;
+    for (const pattern of suspiciousPatterns) {
+      if (pattern.test(args)) {
+        hasSuspiciousPattern = true;
+        break;
+      }
+    }
+
+    if (hasSuspiciousPattern && (command === 'rihal:plan' || command === 'rihal:discuss')) {
+      console.warn(`⚠ "${command}" with args: "${args}". Did you mean /rihal:do or /rihal:council?`);
+    }
+
+    process.exit(0);
+  } catch (err) {
+    console.error(`Hook error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * post-commit: Verify commit format and banned patterns.
+ * Warns (not blocking) if violations found.
+ */
+async function postCommit() {
+  try {
+    const input = await readInputJson();
+    const command = input.tool_input?.command || input.command || '';
+    const output = input.tool_input?.output || input.output || '';
+
+    // Only check git commits
+    if (!command.includes('git commit')) {
+      process.exit(0);
+    }
+
+    // Parse commit message from git output or input
+    // If output contains the committed message, extract it
+    const commitMatch = output.match(/\[.*?\s([a-f0-9]{7})\]/);
+    if (!commitMatch) {
+      // No commit was made (likely dry-run or error)
+      process.exit(0);
+    }
+
+    let commitMsg = output;
+
+    // If -F flag used, try to read the message file
+    const fMatch = command.match(/-F\s+(\S+)/);
+    if (fMatch && fs.existsSync(fMatch[1])) {
+      try {
+        commitMsg += '\n' + fs.readFileSync(fMatch[1], 'utf8');
+      } catch {}
+    }
+
+    // If -m used, extract message from command
+    const mMatch = command.match(/-m\s+["']([^"']+)["']/);
+    if (mMatch) {
+      commitMsg += '\n' + mMatch[1];
+    }
+
+    const violations = [];
+
+    // Check for Co-Authored-By, Generated, 🤖, etc.
+    if (/Co-Authored-By|Generated with Claude|Generated with|🤖/i.test(commitMsg)) {
+      violations.push('Found "Co-Authored-By", "Generated with Claude", or "🤖 Generated" in commit message.');
+    }
+
+    // Check for --no-verify usage
+    if (command.includes('--no-verify')) {
+      violations.push('Used --no-verify flag. Please fix underlying issues instead of bypassing hooks.');
+    }
+
+    // Check commit message format (type(scope): description) on first line only
+    const firstLine = commitMsg.split('\n').find(l => l.trim()) || '';
+    const cc = /^[a-z]+(\([a-z-]+\))?:/.test(firstLine);
+    if (!cc && commitMatch) {
+      violations.push('Commit subject may not follow Conventional Commits format: type(scope): description');
+    }
+
+    if (violations.length > 0) {
+      console.warn('⚠ Commit format warnings:');
+      violations.forEach((v) => console.warn(`  • ${v}`));
+    }
+
+    process.exit(0);
+  } catch (err) {
+    console.error(`Hook error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Main entry point.
+ */
+async function main() {
+  const subcommand = process.argv[2];
+
+  switch (subcommand) {
+    case 'pre-edit':
+      await preEdit();
+      break;
+    case 'pre-workflow':
+      await preWorkflow();
+      break;
+    case 'post-commit':
+      await postCommit();
+      break;
+    default:
+      console.error(`Unknown subcommand: ${subcommand}`);
+      console.error('Usage: rihal-hooks.cjs pre-edit|pre-workflow|post-commit');
+      process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error(`Fatal error: ${err.message}`);
+  process.exit(1);
+});