forge-workflow 0.0.10 → 0.1.0-beta.2

package/lib/beads-health-check.js

@@ -1,188 +0,0 @@
-/**
- * Beads health check smoke test.
- *
- * After Beads init, runs a quick create/close/sync/cleanup cycle to verify
- * the installation is functional.
- *
- * @module beads-health-check
- */
-
-const { execFileSync } = require('node:child_process');
-const fs = require('node:fs');
-const path = require('node:path');
-const { bootstrapBeads, isRecoverableBeadsError } = require('./beads-bootstrap');
-
-/**
- * @typedef {Object} HealthCheckResult
- * @property {boolean} healthy - Whether Beads is operational
- * @property {string|null} failedStep - Which step failed: 'create'|'close'|'sync'|'cleanup', or null
- * @property {string|null} error - Error message if unhealthy, null otherwise
- * @property {string} [warning] - Non-fatal warning message (e.g. sync or cleanup issues)
- */
-
-/**
- * Parse the issue ID from `bd create` stdout.
- *
- * Expects output like "Created issue: forge-xxxx".
- *
- * @param {string} output - stdout from `bd create`
- * @returns {string|null} The issue ID, or null if not found
- */
-function parseIssueId(output) {
-  const match = /Created\s+issue:\s*([\w-]+)/i.exec(output);
-  return match ? match[1].trim() : null;
-}
-
-/**
- * Remove a test issue from the JSONL file by its ID.
- * Silently ignores errors (file missing, locked, malformed lines).
- *
- * @param {string} jsonlPath - Absolute path to the issues.jsonl file
- * @param {string|null} issueId - The issue ID to remove
- */
-function cleanupTestIssue(jsonlPath, issueId) {
-  if (!issueId) return;
-  const raw = fs.readFileSync(jsonlPath, 'utf8');
-  const lines = raw.split('\n').filter(Boolean);
-  const filtered = lines.filter((line) => {
-    try { return JSON.parse(line).id !== issueId; } catch (_e) { /* Expected: malformed JSONL line — keep it as-is */ return true; }
-  });
-  fs.writeFileSync(jsonlPath, filtered.length > 0 ? filtered.join('\n') + '\n' : '');
-}
-
-function appendWarning(existingWarning, nextWarning) {
-  return existingWarning ? `${existingWarning}; ${nextWarning}` : nextWarning;
-}
-
-function createHealthCheckIssue(exec, execOpts) {
-  return exec('bd', [
-    'create',
-    '--title=Setup verification',
-    '--type=task',
-    '--priority=4'
-  ], execOpts);
-}
-
-function createIssueWithRecovery(projectRoot, exec, execOpts, bootstrap) {
-  try {
-    return { output: createHealthCheckIssue(exec, execOpts), warning: null };
-  } catch (createErr) {
-    if (!isRecoverableBeadsError(createErr)) {
-      throw createErr;
-    }
-
-    const bootstrapResult = bootstrap(projectRoot);
-    if (!bootstrapResult?.success) {
-      const extra = bootstrapResult?.warning ? `; ${bootstrapResult.warning}` : '';
-      return {
-        error: `${createErr.message}${extra}`
-      };
-    }
-
-    const bootstrapWarning = bootstrapResult.warning
-      ? `bootstrap warning: ${bootstrapResult.warning}`
-      : `bootstrap warning: recovered via ${bootstrapResult.strategy}`;
-
-    return {
-      output: createHealthCheckIssue(exec, execOpts),
-      warning: bootstrapWarning
-    };
-  }
-}
-
-/**
- * Run a Beads health check smoke test.
- *
- * Creates a temporary issue, closes it, syncs, then cleans up the JSONL file.
- * Uses dependency injection for the exec function to support testing.
- *
- * @param {string} projectRoot - Absolute path to the project root
- * @param {Object} [options={}] - Options
- * @param {Function} [options._exec] - Injectable exec function (defaults to execFileSync)
- * @returns {HealthCheckResult}
- */
-function beadsHealthCheck(projectRoot, options = {}) {
-  const exec = options._exec || execFileSync;
-  const bootstrap = options._bootstrap || ((root) => bootstrapBeads(root, { _exec: exec }));
-  const execOpts = { cwd: projectRoot, encoding: 'utf8' };
-
-  /** @type {string|undefined} */
-  let warning;
-
-  // Step a: Create a test issue
-  /** @type {string|null} */
-  let issueId;
-  try {
-    const createResult = createIssueWithRecovery(projectRoot, exec, execOpts, bootstrap);
-    if (createResult.error) {
-      return {
-        healthy: false,
-        failedStep: 'create',
-        error: createResult.error
-      };
-    }
-
-    warning = createResult.warning || warning;
-
-    issueId = parseIssueId(createResult.output);
-    if (!issueId) {
-      return {
-        healthy: false,
-        failedStep: 'create',
-        error: 'Could not parse issue ID from bd create output'
-      };
-    }
-  } catch (err) {
-    return {
-      healthy: false,
-      failedStep: 'create',
-      error: err.message
-    };
-  }
-
-  // Step b: Close the test issue
-  try {
-    exec('bd', [
-      'close',
-      issueId,
-      '--reason=Setup smoke test'
-    ], execOpts);
-  } catch (err) {
-    // Best-effort cleanup: remove the test issue from JSONL so it doesn't leak
-    try {
-      cleanupTestIssue(path.join(projectRoot, '.beads', 'issues.jsonl'), issueId);
-    } catch (_cleanupErr) {
-      // Expected: JSONL cleanup may fail if file is locked or missing — nothing more we can do
-    }
-    return {
-      healthy: false,
-      failedStep: 'close',
-      error: err.message
-    };
-  }
-
-  // Step c: Sync (may fail without a remote -- that's OK)
-  try {
-    exec('bd', ['sync'], execOpts);
-  } catch (syncErr) {
-    // Sync failure is non-fatal (no remote configured is common)
-    warning = appendWarning(warning, `bd sync warning: ${syncErr.message}`);
-  }
-
-  // Step d: Remove the test issue from JSONL
-  try {
-    cleanupTestIssue(path.join(projectRoot, '.beads', 'issues.jsonl'), issueId);
-  } catch (cleanupErr) {
-    // Cleanup failure is non-fatal
-    warning = appendWarning(warning, `cleanup warning: ${cleanupErr.message}`);
-  }
-
-  return {
-    healthy: true,
-    failedStep: null,
-    error: null,
-    ...(warning ? { warning } : {})
-  };
-}
-
-module.exports = { beadsHealthCheck, parseIssueId };

package/lib/commands/commands-reset.js

@@ -1,147 +0,0 @@
-'use strict';
-
-/**
- * @module commands-reset
- *
- * Reset agent command files to match the canonical source (commands/*.md or .claude/commands/*.md).
- * Rebuilds adapted files via sync-commands and optionally writes them.
- *
- * Used by `forge commands reset [--dry-run] [--all] [command-name]`.
- */
-
-const fs = require('node:fs');
-const path = require('node:path');
-const {
-  syncCommands,
-  contentHash,
-  resolveCanonicalCommandsDir,
-  writeSyncManifest,
-} = require('../../scripts/sync-commands.js');
-
-function validateCommandName(commandName) {
-  if (commandName && !/^[a-z0-9-]+$/.test(commandName)) {
-    return [`Invalid command name: "${commandName}" - only lowercase letters, numbers, and hyphens allowed`];
-  }
-
-  return [];
-}
-
-function ensureCanonicalCommandExists(repoRoot, canonicalDir, commandName) {
-  if (!commandName) {
-    return [];
-  }
-
-  if (fs.existsSync(path.join(canonicalDir, `${commandName}.md`))) {
-    return [];
-  }
-
-  const canonicalLabel = path.relative(repoRoot, canonicalDir).replaceAll('\\', '/');
-  return [`Command not found: ${canonicalLabel}/${commandName}.md`];
-}
-
-function filterPlannedEntries(entries, commandName, all) {
-  if (commandName && all !== true) {
-    return entries.filter(entry =>
-      entry.filename.replaceAll('.prompt.md', '').replaceAll('.md', '') === commandName ||
-      entry.dir.includes(`/${commandName}/`)
-    );
-  }
-
-  return entries;
-}
-
-function recordEntryResult(entry, reset, skipped, dryRun) {
-  const relativeFile = path.join(entry.dir, entry.filename);
-
-  if (dryRun) {
-    if (fs.existsSync(entry.filePath)) {
-      const existing = fs.readFileSync(entry.filePath, 'utf8');
-      if (contentHash(existing) === contentHash(entry.content)) {
-        skipped.push({ agent: entry.agent, file: relativeFile });
-      } else {
-        reset.push({ agent: entry.agent, file: relativeFile });
-      }
-    } else {
-      reset.push({ agent: entry.agent, file: relativeFile });
-    }
-    return;
-  }
-
-  const targetDir = path.dirname(entry.filePath);
-  if (!fs.existsSync(targetDir)) {
-    fs.mkdirSync(targetDir, { recursive: true });
-  }
-
-  if (fs.existsSync(entry.filePath)) {
-    const existing = fs.readFileSync(entry.filePath, 'utf8');
-    if (contentHash(existing) === contentHash(entry.content)) {
-      skipped.push({ agent: entry.agent, file: relativeFile });
-      return;
-    }
-  }
-
-  fs.writeFileSync(entry.filePath, entry.content);
-  reset.push({ agent: entry.agent, file: relativeFile });
-}
-
-function resetCommands({ repoRoot, commandName, all, dryRun }) {
-  const errors = [];
-  const reset = [];
-  const skipped = [];
-
-  errors.push(...validateCommandName(commandName));
-  if (errors.length > 0) {
-    return { reset, skipped, errors };
-  }
-
-  const canonicalDir = resolveCanonicalCommandsDir(repoRoot);
-  if (!canonicalDir) {
-    errors.push('Canonical source directory not found: commands/ or .claude/commands/');
-    return { reset, skipped, errors };
-  }
-
-  errors.push(...ensureCanonicalCommandExists(repoRoot, canonicalDir, commandName));
-  if (errors.length > 0) {
-    return { reset, skipped, errors };
-  }
-
-  const result = syncCommands({ dryRun: true, check: false, repoRoot, canonicalDir });
-  if (!result.planned || result.planned.length === 0) {
-    return { reset, skipped, errors };
-  }
-
-  const entries = filterPlannedEntries(result.planned, commandName, all);
-  for (const entry of entries) {
-    recordEntryResult(entry, reset, skipped, dryRun);
-  }
-
-  if (!dryRun) {
-    // Refresh the manifest using the full expected sync set without rewriting
-    // unrelated command files that were intentionally excluded from this reset.
-    writeSyncManifest(repoRoot, result.planned);
-  }
-
-  return { reset, skipped, errors };
-}
-
-module.exports = {
-  name: 'commands-reset',
-  description: 'Reset generated agent command files to canonical content',
-  handler: async (args, flags, repoRoot) => {
-    const commandName = args.find(arg => !arg.startsWith('-'));
-    const result = resetCommands({
-      repoRoot,
-      commandName,
-      all: Boolean(flags.all),
-      dryRun: Boolean(flags.dryRun),
-    });
-
-    if (result.errors.length > 0) {
-      return { success: false, error: result.errors.join('; ') };
-    }
-
-    return { success: true, ...result };
-  },
-  resetCommands,
-  resolveCanonicalCommandsDir,
-};

package/opencode.json

@@ -1,67 +0,0 @@
-{
-  "$schema": "https://opencode.ai/config.json",
-  "permission": {
-    "*": "ask",
-    "bash": {
-      "*": "ask",
-      "git status *": "allow",
-      "git log *": "allow",
-      "git diff *": "allow",
-      "git branch *": "allow",
-      "git show *": "allow",
-      "git remote *": "allow",
-      "git stash *": "allow",
-      "git tag *": "allow",
-      "git rev-parse *": "allow",
-      "git describe *": "allow",
-      "git ls-files *": "allow",
-      "git blame *": "allow",
-      "git shortlog *": "allow",
-      "git add *": "allow",
-      "git commit *": "allow",
-      "git push *": "allow",
-      "git checkout *": "allow",
-      "git switch *": "allow",
-      "git merge *": "allow",
-      "git rebase *": "ask",
-      "git cherry-pick *": "allow",
-      "bd *": "allow",
-      "gh *": "allow",
-      "ls *": "allow",
-      "cat *": "allow",
-      "grep *": "allow",
-      "find *": "allow",
-      "pwd *": "allow",
-      "which *": "allow",
-      "echo *": "allow",
-      "head *": "allow",
-      "tail *": "allow",
-      "sort *": "allow",
-      "wc *": "allow",
-      "awk *": "allow",
-      "sed *": "allow",
-      "stat *": "allow",
-      "du *": "allow",
-      "df *": "allow",
-      "file *": "allow",
-      "mkdir *": "allow",
-      "touch *": "allow",
-      "cp *": "allow",
-      "mv *": "allow",
-      "bun *": "allow",
-      "bunx *": "allow",
-      "npm *": "allow",
-      "npx *": "allow",
-      "node *": "allow",
-
-      "git worktree *": "allow",
-      "git reset --hard *": "ask",
-      "rm -rf *": "deny",
-      "git push --force *": "deny",
-      "git push -f *": "deny"
-    },
-    "edit": {
-      "*": "allow"
-    }
-  }
-}