forge-workflow 0.0.9 → 0.1.0-beta.2

package/scripts/bootstrap-windows-tools.sh

@@ -0,0 +1,78 @@
+#!/usr/bin/env bash
+# Shared Windows/WSL command bootstrap for bash entrypoints.
+
+if [[ -n "${_FORGE_BOOTSTRAP_WINDOWS_TOOLS_LOADED:-}" ]]; then
+  return 0 2>/dev/null || exit 0
+fi
+_FORGE_BOOTSTRAP_WINDOWS_TOOLS_LOADED=1
+
+_forge_to_unix_path() {
+  local raw="$1"
+  if command -v wslpath >/dev/null 2>&1; then
+    wslpath -u "$raw" 2>/dev/null && return 0
+  fi
+  if command -v cygpath >/dev/null 2>&1; then
+    cygpath -u "$raw" 2>/dev/null && return 0
+  fi
+  printf '%s\n' "$raw"
+}
+
+_forge_resolve_tool() {
+  local name="$1"
+  local found=""
+
+  found="$(command -v "$name" 2>/dev/null || true)"
+  if [[ -n "$found" ]]; then
+    printf '%s\n' "$found"
+    return 0
+  fi
+
+  if command -v where.exe >/dev/null 2>&1; then
+    found="$(where.exe "$name" 2>/dev/null | tr -d '\r' | head -n 1 || true)"
+    if [[ -n "$found" ]]; then
+      _forge_to_unix_path "$found"
+      return 0
+    fi
+  fi
+
+  return 1
+}
+
+if [[ -z "${BD_CMD:-}" ]]; then
+  BD_CMD="$(_forge_resolve_tool bd || true)"
+fi
+if [[ -n "${BD_CMD:-}" ]]; then
+  export BD_CMD
+fi
+
+if [[ -z "${JQ_CMD:-}" ]]; then
+  JQ_CMD="$(_forge_resolve_tool jq || true)"
+fi
+if [[ -n "${JQ_CMD:-}" ]]; then
+  export JQ_CMD
+fi
+
+if [[ -z "${GH_CMD:-}" ]]; then
+  GH_CMD="$(_forge_resolve_tool gh || true)"
+fi
+if [[ -n "${GH_CMD:-}" ]]; then
+  export GH_CMD
+fi
+
+if [[ -n "${BD_CMD:-}" ]]; then
+  bd() {
+    command "$BD_CMD" "$@"
+  }
+fi
+
+if [[ -n "${JQ_CMD:-}" ]]; then
+  jq() {
+    command "$JQ_CMD" "$@"
+  }
+fi
+
+if [[ -n "${GH_CMD:-}" ]]; then
+  gh() {
+    command "$GH_CMD" "$@"
+  }
+fi

package/scripts/branch-protection.js

@@ -131,7 +131,7 @@ function main() {
   const currentBranch = getCurrentBranch();
 
   if (isProtectedBranch(currentBranch)) {
-    // Allow beads-only commits (issue tracking metadata) to push directly
+    // Beads runtime metadata is local state. Do not bypass protected branches for it.
     try {
       let upstream;
       try {
@@ -150,8 +150,7 @@ function main() {
       if (changedFiles.length === 0) {
         console.error(`${YELLOW}Note: no changed files detected — nothing to bypass${RESET}`);
       } else if (changedFiles.every(f => f.startsWith('.beads/'))) {
-        console.error(`${YELLOW}Beads-only push to '${currentBranch}' — allowed${RESET}`);
-        process.exit(0);
+        console.error(`${YELLOW}Beads metadata is local runtime state; protected branches do not accept .beads-only pushes.${RESET}`);
       }
     } catch (_e) {
       console.error(`${YELLOW}Note: could not detect beads-only push (upstream ref missing?) — blocking by default${RESET}`);

package/scripts/check-agents.js

@@ -5,11 +5,12 @@
  *
  * CLI command that validates all agent configs are complete and in sync.
  *
- * 1. Runs syncCommands({ check: true }) to verify agent command files match canonical source
- * 2. Reads lib/agents/*.plugin.json to verify each agent with capabilities.commands: true
- *    has its command directory populated with expected files
- * 3. Reports: missing files, out-of-sync files, stale files
- * 4. Exits 0 if all clean, exits non-zero if issues found
+ * 1. Runs the skills drift check (lib/skills-sync) to verify generated agent
+ *    skill mirrors (e.g. .codex/skills) match the canonical root skills/ source.
+ * 2. Reads lib/agents/*.plugin.json to validate each plugin's schema/parity
+ *    (support metadata, rules/skills scaffold paths, deprecated-tier consistency).
+ * 3. Reports: skill drift, missing/stale skills, plugin parity errors.
+ * 4. Exits 0 if all clean, exits non-zero if issues found.
  *
  * Usage:
  *   node scripts/check-agents.js
@@ -18,51 +19,22 @@
  *   checkAgents(repoRoot) -> { errors: string[], warnings: string[] }
  */
 
-const { syncCommands } = require('./sync-commands');
-const { AGENT_ADAPTERS } = require('./sync-commands');
 const path = require('path');
 const fs = require('fs');
+const { checkSkillsSync } = require('../lib/skills-sync');
 const { validatePluginSchema } = require('../lib/plugin-manager');
 
-const SYNC_ADAPTER_BY_PLUGIN_ID = Object.freeze({
-  claude: 'claude-code',
-  cline: 'cline',
-  codex: 'codex',
-  copilot: 'github-copilot',
-  cursor: 'cursor',
-  kilocode: 'kilo-code',
-  opencode: 'opencode',
-  roo: 'roo-code',
-});
-
-function normalizeRelativeDir(dir) {
-  if (!dir) return null;
-  return String(dir).replace(/\\/g, '/').replace(/\/+$/, '');
-}
-
-function getDeclaredCommandDir(plugin) {
-  const dirs = plugin.directories || {};
-  return dirs.commands || dirs.workflows || dirs.prompts || dirs.skills || null;
-}
-
-function getExpectedCommandDir(plugin) {
-  const adapterId = SYNC_ADAPTER_BY_PLUGIN_ID[plugin.id];
-  if (!adapterId) {
-    return null;
-  }
-
-  const adapter = AGENT_ADAPTERS[adapterId];
-  if (!adapter) {
-    return null;
-  }
-
-  if (plugin.id === 'codex') {
-    return normalizeRelativeDir(plugin.directories?.skills || adapter.baseDir);
-  }
-
-  return normalizeRelativeDir(adapter.baseDir);
-}
-
+/**
+ * Validate a single plugin's schema + capability/scaffold parity.
+ *
+ * Command-surface parity is intentionally NOT validated: Forge is skills-only
+ * (the .claude/commands/.cursor/commands/.codex/skills command surface was
+ * removed in PR-A0). The surviving checks cover support metadata, the rules and
+ * skills scaffold paths, and deprecated-tier consistency.
+ *
+ * @param {object} plugin
+ * @param {string[]} errors - mutated with any parity errors
+ */
 function validatePluginParity(plugin, errors) {
   const validation = validatePluginSchema(plugin);
   if (!validation.valid) {
@@ -78,25 +50,6 @@ function validatePluginParity(plugin, errors) {
   const dirs = plugin.directories || {};
   const supportStatus = plugin.support?.status;
 
-  if (capabilities.commands) {
-    const expectedDir = getExpectedCommandDir(plugin);
-    const declaredDir = normalizeRelativeDir(getDeclaredCommandDir(plugin));
-
-    if (!expectedDir) {
-      errors.push(
-        `Plugin "${plugin.name}" (${plugin.id}) declares commands support but has no Forge sync adapter.`
-      );
-    } else if (!declaredDir) {
-      errors.push(
-        `Plugin "${plugin.name}" (${plugin.id}) declares commands support but has no command directory configured.`
-      );
-    } else if (declaredDir !== expectedDir) {
-      errors.push(
-        `Plugin "${plugin.name}" (${plugin.id}) command directory "${declaredDir}" does not match sync output "${expectedDir}".`
-      );
-    }
-  }
-
   if (capabilities.rules && !dirs.rules) {
     errors.push(
       `Plugin "${plugin.name}" (${plugin.id}) declares rules capability but has no scaffold path configured.`
@@ -136,47 +89,34 @@ function checkAgents(repoRoot) {
   /** @type {string[]} */
   const warnings = [];
 
-  // ---- 1. Run sync check ----
-  let syncResult;
+  // ---- 1. Skills drift check ----
+  let driftResult;
   try {
-    syncResult = syncCommands({ check: true, dryRun: false, repoRoot });
+    driftResult = checkSkillsSync({ repoRoot });
   } catch (err) {
-    errors.push(`Sync check failed: ${err.message}`);
+    errors.push(`Skills sync check failed: ${err.message}`);
     return { errors, warnings };
   }
 
-  if (syncResult.empty) {
-    errors.push('No command files found in .claude/commands/ — cannot verify sync.');
+  const canonicalSkillsDir = path.join(repoRoot, 'skills');
+  if (!fs.existsSync(canonicalSkillsDir)) {
+    errors.push('No canonical skills found in skills/ — cannot verify skill sync.');
     return { errors, warnings };
-  } else {
-    if (syncResult.manifestMissing) {
-      warnings.push(
-        'Sync manifest (.forge/sync-manifest.json) not found — stale file detection skipped. ' +
-        'Run "node scripts/sync-commands.js" to generate it.'
-      );
-    }
+  }
 
-    if (syncResult.outOfSync && syncResult.outOfSync.length > 0) {
-      for (const entry of syncResult.outOfSync) {
-        const relPath = path.join(entry.dir, entry.filename);
-        const exists = fs.existsSync(entry.filePath);
-        const status = exists ? 'modified' : 'missing';
-        errors.push(`Out of sync [${entry.agent}]: ${relPath} (${status})`);
-      }
-    }
+  if (driftResult.checkedAgents.length === 0) {
+    warnings.push(
+      'No generated agent skill directories found (e.g. .codex/skills) — skill drift check skipped. ' +
+      'Run "forge setup" or "skills sync" to populate them.'
+    );
+  }
 
-    if (syncResult.staleFiles && syncResult.staleFiles.length > 0) {
-      for (const filePath of syncResult.staleFiles) {
-        const relPath = path.relative(repoRoot, filePath);
-        errors.push(`Stale file (no longer generated, should be removed): ${relPath}`);
-      }
-    }
+  for (const d of driftResult.drift) {
+    errors.push(`Out of sync [${d.agent}]: ${d.skill}/${d.file} (${d.status})`);
   }
 
   // ---- 2. Validate plugin catalog ----
   const pluginDir = path.join(repoRoot, 'lib', 'agents');
-  /** @type {object[]} */
-  const plugins = [];
 
   if (!fs.existsSync(pluginDir)) {
     warnings.push('No plugin directory found at lib/agents/ — plugin catalog validation skipped.');
@@ -190,54 +130,11 @@ function checkAgents(repoRoot) {
     for (const file of pluginFiles) {
       try {
         const plugin = JSON.parse(fs.readFileSync(path.join(pluginDir, file), 'utf8'));
-        plugins.push(plugin);
         validatePluginParity(plugin, errors);
       } catch (_err) {
         errors.push(`Failed to parse plugin file: lib/agents/${file}`);
       }
     }
-
-    // For each plugin with commands: true, verify its command directory has files
-    for (const plugin of plugins) {
-      if (!plugin.capabilities || !plugin.capabilities.commands) {
-        continue;
-      }
-
-      // Find the command directory from the plugin's directories config
-      const dirs = plugin.directories || {};
-      // Plugins use different keys: commands, workflows, prompts, skills
-      const commandDir = dirs.commands || dirs.workflows || dirs.prompts;
-
-      if (!commandDir) {
-        // Plugin declares commands: true but has no command directory configured
-        // Codex is the only agent that uses skills as its command mechanism
-        if (plugin.id === 'codex' && dirs.skills) {
-          // Codex CLI: commands live in .codex/skills/<name>/SKILL.md — skip standard check
-          continue;
-        }
-        warnings.push(
-          `Plugin "${plugin.name}" (${plugin.id}) has commands: true but no command directory configured.`
-        );
-        continue;
-      }
-
-      const absCmdDir = path.join(repoRoot, commandDir);
-
-      if (!fs.existsSync(absCmdDir)) {
-        errors.push(
-          `Plugin "${plugin.name}" (${plugin.id}) has commands: true but directory "${commandDir}" does not exist.`
-        );
-        continue;
-      }
-
-      // Check the directory has at least one file
-      const files = fs.readdirSync(absCmdDir).filter((f) => !f.startsWith('.'));
-      if (files.length === 0) {
-        errors.push(
-          `Plugin "${plugin.name}" (${plugin.id}) has commands: true but directory "${commandDir}" is empty.`
-        );
-      }
-    }
   }
 
   return { errors, warnings };

package/scripts/commitlint.js

@@ -12,7 +12,9 @@ const isWindows = process.platform === 'win32';
 
 const commitMsgFile = process.argv[2];
 if (!commitMsgFile) {
-  console.error('❌ No commit message file provided');
+  // Write synchronously so the message is flushed before exit: on Windows the
+  // stderr pipe is async and process.exit() can otherwise truncate it.
+  require('node:fs').writeSync(2, '❌ No commit message file provided\n');
   process.exit(1);
 }
 

package/scripts/conflict-detect.sh

@@ -17,6 +17,9 @@
 set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+if [[ -f "$SCRIPT_DIR/bootstrap-windows-tools.sh" ]]; then
+  source "$SCRIPT_DIR/bootstrap-windows-tools.sh"
+fi
 
 # Source file-index helpers (file_index_read, file_index_get)
 source "$SCRIPT_DIR/file-index.sh" || { echo "FATAL: failed to source file-index.sh" >&2; exit 2; }

package/scripts/dep-guard-analyze.js

@@ -32,26 +32,61 @@ function normalizeSingleIssuePayload(payload) {
 	return {};
 }
 
+function readStdinPayload() {
+  const raw = fs.readFileSync(0, 'utf8');
+  if (!raw.trim()) {
+    throw new Error('Expected JSON payload on stdin');
+  }
+
+  const payload = JSON.parse(raw);
+  return {
+    currentIssue: normalizeSingleIssuePayload(payload.currentIssue),
+    openIssues: normalizeListPayload(payload.openIssues),
+    inProgressIssues: normalizeListPayload(payload.inProgressIssues),
+    taskFile: payload.taskFile,
+    repositoryRoot: payload.repositoryRoot || process.cwd(),
+  };
+}
+
 function main() {
-  const [
-    currentIssueFile,
-    openIssuesFile,
-    inProgressIssuesFile,
-    taskFile,
-    repositoryRoot = process.cwd(),
-  ] = process.argv.slice(2);
+  const args = process.argv.slice(2);
+  let currentIssue;
+  let openIssues;
+  let taskFile;
+  let repositoryRoot;
 
-  if (!currentIssueFile || !openIssuesFile || !inProgressIssuesFile || !taskFile) {
-    throw new Error(
-      'Usage: dep-guard-analyze.js <current-issue.json> <open-issues.json> <in-progress-issues.json> <task-file> [repository-root]',
-    );
-  }
+  if (args[0] === '--stdin') {
+    const payload = readStdinPayload();
+    currentIssue = payload.currentIssue;
+    openIssues = [
+      ...payload.openIssues,
+      ...payload.inProgressIssues,
+    ].filter((issue) => issue && issue.id && issue.id !== currentIssue.id);
+    taskFile = payload.taskFile;
+    repositoryRoot = payload.repositoryRoot;
+  } else {
+    const [
+      currentIssueFile,
+      openIssuesFile,
+      inProgressIssuesFile,
+      taskFileArg,
+      repositoryRootArg = process.cwd(),
+    ] = args;
 
-  const currentIssue = normalizeSingleIssuePayload(readJsonFile(currentIssueFile));
-  const openIssues = [
-    ...normalizeListPayload(readJsonFile(openIssuesFile)),
-    ...normalizeListPayload(readJsonFile(inProgressIssuesFile)),
-  ].filter((issue) => issue && issue.id && issue.id !== currentIssue.id);
+    if (!currentIssueFile || !openIssuesFile || !inProgressIssuesFile || !taskFileArg) {
+      throw new Error(
+        'Usage: dep-guard-analyze.js <current-issue.json> <open-issues.json> <in-progress-issues.json> <task-file> [repository-root]',
+      );
+    }
+
+    currentIssue = normalizeSingleIssuePayload(readJsonFile(currentIssueFile));
+    openIssues = [
+      ...normalizeListPayload(readJsonFile(openIssuesFile)),
+      ...normalizeListPayload(readJsonFile(inProgressIssuesFile)),
+    ].filter((issue) => issue && issue.id && issue.id !== currentIssue.id);
+    taskFile = taskFileArg;
+    repositoryRoot = repositoryRootArg;
+  }
 
   const result = analyzePhase3Dependencies({
     currentIssue,

package/scripts/dep-guard-keyword-ripple.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+'use strict';
+
+const {
+	parseActiveIssueLines,
+	renderKeywordRippleReport,
+} = require('../lib/dep-guard/keyword-ripple.js');
+
+function main() {
+	try {
+		const report = renderKeywordRippleReport({
+			issueId: process.env.ISSUE_ID || '',
+			sourceTitle: process.env.SOURCE_TITLE || '',
+			activeIssues: parseActiveIssueLines(process.env.LIST_OUTPUT || ''),
+		});
+
+		if (report.overlapCount > 0) {
+			process.stdout.write(`⚠️  ${report.output}\n`);
+			return;
+		}
+
+		process.stdout.write(`✅ ${report.output}\n`);
+	} catch (error) {
+		console.error(`dep-guard-keyword-ripple: ${error.message}`);
+		process.exit(1);
+	}
+}
+
+main();

package/scripts/dep-guard-render-review.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+
+function readAnalysis() {
+  const raw = fs.readFileSync(0, 'utf8');
+  if (!raw.trim()) {
+    throw new Error('Expected JSON analysis payload on stdin');
+  }
+  return JSON.parse(raw);
+}
+
+function renderPhase3Review(analysis) {
+  const detectorCategories = Object.entries(analysis.scores ?? {})
+    .filter(([name, score]) => name !== 'rubric' && Number(score) > 0)
+    .map(([name]) => name);
+
+  const lines = [
+    '',
+    `Structured dependency review for ${analysis.currentIssue.id}...`,
+    '',
+  ];
+
+  if (!Array.isArray(analysis.issues) || analysis.issues.length === 0) {
+    lines.push('No conflicts detected');
+    return `${lines.join('\n')}\n`;
+  }
+
+  const seenPairs = new Set();
+  for (const finding of analysis.issues) {
+    const key = `${analysis.currentIssue.id}->${finding.targetIssueId}`;
+    if (seenPairs.has(key)) {
+      continue;
+    }
+    seenPairs.add(key);
+    lines.push(`Issue pair: ${analysis.currentIssue.id} -> ${finding.targetIssueId}`);
+  }
+
+  lines.push(`Rubric score: ${analysis.scores?.rubric ?? 0}`);
+  lines.push(
+    `Confidence: ${(analysis.confidence?.score ?? 0).toFixed(2)}${
+      analysis.confidence?.belowThreshold ? ' (below 70% threshold)' : ''
+    }`,
+  );
+  lines.push(`Detector categories: ${detectorCategories.join(', ') || 'none'}`);
+  lines.push(`Needs user decision: ${analysis.needsUserDecision ? 'yes' : 'no'}`);
+
+  if (Array.isArray(analysis.detectorConflicts) && analysis.detectorConflicts.length > 0) {
+    lines.push('Conflicts:');
+    for (const conflict of analysis.detectorConflicts) {
+      lines.push(`  - ${conflict}`);
+    }
+  }
+
+  if (Array.isArray(analysis.proposals) && analysis.proposals.length > 0) {
+    lines.push('');
+    lines.push('Proposed dependency updates:');
+    for (const proposal of analysis.proposals) {
+      lines.push(`  - ${proposal.dependentIssueId} depends on ${proposal.dependsOnIssueId}`);
+      if (Array.isArray(proposal.pros) && proposal.pros.length > 0) {
+        lines.push(`    Pros: ${proposal.pros.join('; ')}`);
+      }
+      if (Array.isArray(proposal.cons) && proposal.cons.length > 0) {
+        lines.push(`    Cons: ${proposal.cons.join('; ')}`);
+      }
+    }
+  }
+
+  return `${lines.join('\n')}\n`;
+}
+
+function main() {
+  process.stdout.write(renderPhase3Review(readAnalysis()));
+}
+
+try {
+  main();
+} catch (error) {
+  process.stderr.write(`${error.message}\n`);
+  process.exit(1);
+}
+
+module.exports = {
+  renderPhase3Review,
+};