@magnusekdahl/parallix 1.0.0

package/lib/index.js

@@ -0,0 +1,77 @@
+/**
+ * Barrel re-export for parallix/lib/.
+ *
+ * Re-exports all grouped modules under named properties (e.g.
+ * `require('../lib').commands.setup`). This file does NOT restore
+ * flat subpath imports (e.g. `require('../lib/setup')`) — those
+ * entrypoints were removed during the restructure and any remaining
+ * consumers should be updated to use the new grouped paths.
+ *
+ * Directory layout:
+ *   agents/   — AI agent launchers and session management
+ *   commands/ — Workflow command handlers (dispatcher entry points)
+ *   core/     — Shared infrastructure (no command-handler imports)
+ *   review/   — Review subsystem (artifacts, commands, loop, polling, prompts, state)
+ *   tools/    — External integrations and supporting workflow libraries
+ */
+
+'use strict';
+
+// agents/
+module.exports.agents = require('./agents/agents');
+module.exports.claude = require('./agents/claude');
+module.exports.claudeTelemetry = require('./agents/claude-telemetry');
+module.exports.codex = require('./agents/codex');
+module.exports.codexTelemetry = require('./agents/codex-telemetry');
+module.exports.limitHit = require('./agents/limit-hit');
+module.exports.mistral = require('./agents/mistral');
+module.exports.opencode = require('./agents/opencode');
+
+// commands/
+module.exports.active = require('./commands/active');
+module.exports.checkpoint = require('./commands/checkpoint');
+module.exports.config = require('./commands/config');
+module.exports.coverageGate = require('./commands/coverage-gate');
+module.exports.diff = require('./commands/diff');
+module.exports.draft = require('./commands/draft');
+module.exports.handoff = require('./commands/handoff');
+module.exports.integrate = require('./commands/integrate');
+module.exports.missionStart = require('./commands/mission-start');
+module.exports.rebase = require('./commands/rebase');
+module.exports.repairHandoff = require('./commands/repair-handoff');
+module.exports.resolveConflict = require('./commands/resolve-conflict');
+module.exports.setup = require('./commands/setup');
+module.exports.stats = require('./commands/stats');
+module.exports.statsBackfill = require('./commands/stats-backfill');
+module.exports.status = require('./commands/status');
+module.exports.verify = require('./commands/verify');
+
+// core/
+module.exports.fmt = require('./core/fmt');
+module.exports.git = require('./core/git');
+module.exports.gitignore = require('./core/gitignore');
+module.exports.missionUtils = require('./core/mission-utils');
+module.exports.persistentDataMigration = require('./core/persistent-data-migration');
+module.exports.productConfig = require('./core/product-config');
+module.exports.runtimeMatrix = require('./core/runtime-matrix');
+module.exports.spawnTee = require('./core/spawn-tee');
+module.exports.stateMap = require('./core/state-map');
+module.exports.storage = require('./core/storage');
+module.exports.verification = require('./core/verification');
+
+// review/
+module.exports.review = require('./review/review');
+module.exports.reviewArtifacts = require('./review/review-artifacts');
+module.exports.reviewCommands = require('./review/review-commands');
+module.exports.reviewEvents = require('./review/review-events');
+module.exports.reviewLoop = require('./review/review-loop');
+module.exports.reviewPolling = require('./review/review-polling');
+module.exports.reviewPrompts = require('./review/review-prompts');
+module.exports.reviewState = require('./review/review-state');
+
+// tools/
+module.exports.backlog = require('./tools/backlog');
+module.exports.forgejo = require('./tools/forgejo');
+module.exports.gatekeeper = require('./tools/gatekeeper');
+module.exports.setupReview = require('./tools/setup-review');
+module.exports.sessions = require('./tools/sessions');

package/lib/review/rebase.js

@@ -0,0 +1,163 @@
+/**
+ * Rebase helpers for pre-review workflow.
+ *
+ * Extracted from review-loop.js to break the circular dependency:
+ *   handoff.js -> review-loop.js -> handoff.js
+ *
+ * Both handoff.js and review-loop.js import from this module instead.
+ */
+
+const path = require('path');
+const fmt = require('../core/fmt');
+const { git } = require('../core/git');
+const { resolveWorktree } = require('../core/mission-utils');
+const { isProviderEnabled } = require('./review-adapter');
+
+const SHARED_FILE_REBASE_CONFLICT_RE = /shared file(?:\(s\))? require agent-assisted resolution|shared-file-conflicts/i;
+
+/**
+ * Auto-commit safe mission artifacts before rebase.
+ * Only touches mission-generated files, task files, and stats CSV.
+ */
+async function commitSafeMissionArtifacts(slug, worktree, {
+  taskFile = null,
+  gitFn = git,
+  log = fmt.log.plain,
+  error = fmt.log.plainError,
+  isMissionArtifactFn = require('../core/mission-utils').isMissionArtifact,
+  isWorkflowGeneratedArtifactFn = require('../core/mission-utils').isWorkflowGeneratedArtifact,
+  resolveStatsRelPathFn = () => null
+} = {}) {
+  const rootDir = worktree || process.cwd();
+  const statusResult = gitFn(['-C', rootDir, 'status', '--porcelain=v1', '-z']);
+  if (statusResult.status !== 0 || !statusResult.stdout) {
+    return { ok: true, dirty: false };
+  }
+
+  const parsePorcelainZ = (stdout) => {
+    const entries = String(stdout).split('\0').filter(Boolean);
+    const dirty = [];
+    for (let i = 0; i < entries.length; i += 1) {
+      const entry = entries[i];
+      const xy = entry.slice(0, 2);
+      const file = entry.slice(3);
+      const record = { xy, file, paths: [file] };
+      if ((xy[0] === 'R' || xy[0] === 'C') && i + 1 < entries.length) {
+        const source = entries[i + 1];
+        record.source = source;
+        record.paths.push(source);
+        i += 1;
+      }
+      dirty.push(record);
+    }
+    return dirty;
+  };
+
+  const dirtyFiles = parsePorcelainZ(statusResult.stdout);
+
+  const unmerged = dirtyFiles.filter(f => ['DD', 'AU', 'UD', 'UA', 'DU', 'AA', 'UU'].includes(f.xy));
+  if (unmerged.length > 0) {
+    error(fmt.status('FAIL', `Cannot auto-commit: unmerged/conflicting files detected:\n${unmerged.map(f => `       - ${f.file}`).join('\n')}`));
+    return { ok: false, dirty: true, unsafe: true };
+  }
+
+  const resolvedTaskFile = taskFile ? path.relative(rootDir, taskFile) : null;
+  const statsRelPath = resolveStatsRelPathFn(rootDir);
+  const isSafeToCommit = (file) =>
+    isWorkflowGeneratedArtifactFn(file)
+    || isMissionArtifactFn(file, slug, rootDir)
+    || (resolvedTaskFile && file === resolvedTaskFile)
+    || (statsRelPath && file === statsRelPath);
+
+  const unsafeFiles = dirtyFiles
+    .flatMap(f => f.paths)
+    .filter(file => !isSafeToCommit(file));
+  if (unsafeFiles.length > 0) {
+    error(fmt.status('FAIL', `Cannot auto-commit: dirty files include non-mission paths:`));
+    unsafeFiles.forEach(file => error(`       - ${file}`));
+    return { ok: false, dirty: true, unsafe: true };
+  }
+
+  log(`Auto-committing safe mission artifacts for ${fmt.branch(`mission/${slug}`)} before rebase...`);
+  dirtyFiles.forEach(f => {
+    log(`       - ${f.file}`);
+    gitFn(['-C', rootDir, 'add', '--', f.file]);
+  });
+
+  const commitRes = gitFn(['-C', rootDir, 'commit', '-m', `workflow(${slug}): auto-commit mission artifacts before pre-review rebase`]);
+  if (commitRes.status === 0) {
+    log(fmt.status('PASS', 'Mission artifacts committed.'));
+    return { ok: true, dirty: true };
+  } else {
+    const failureMsg = [commitRes.stderr, commitRes.stdout].filter(Boolean).join('\n').trim();
+    error(fmt.status('FAIL', `Failed to commit mission artifacts: ${failureMsg}`));
+    return { ok: false, dirty: true };
+  }
+}
+
+/**
+ * Rebase the mission branch onto the latest primary/main branch before launching a reviewer.
+ *
+ * Always commits safe worktree state first, then rebases via the workflow CLI.
+ * In standalone (provider-disabled) mode, skips the rebase after committing.
+ */
+async function rebaseBeforeReviewRound(slug, {
+  runFn = require('child_process').spawnSync,
+  gitFn = git,
+  taskFile = null,
+  worktree = resolveWorktree(slug) || process.cwd(),
+  log = fmt.log.plain,
+  error = fmt.log.plainError,
+  isReviewProviderEnabledFn = undefined,
+  legacyIsForgejoReviewEnabledFn = null,
+  isForgejoReviewEnabledFn = null
+} = {}) {
+  const cleanup = await commitSafeMissionArtifacts(slug, worktree, { taskFile, gitFn, log, error });
+  if (!cleanup.ok) {
+    error(fmt.status('WARN', 'Worktree is dirty with unsafe or conflicted files. Rebase may fail.'));
+    return { ok: false, sharedFileConflicts: false };
+  }
+
+  const forgejoEnabledFn = isReviewProviderEnabledFn
+    || legacyIsForgejoReviewEnabledFn
+    || isForgejoReviewEnabledFn
+    || isProviderEnabled;
+  const forgejoEnabled = forgejoEnabledFn(worktree);
+  if (!forgejoEnabled) {
+    log(fmt.status('INFO', `Review provider disabled; committed worktree state and skipping pre-review rebase for ${fmt.branch(`mission/${slug}`)}.`));
+    return { ok: true, sharedFileConflicts: false };
+  }
+
+  const workflowCli = path.resolve(__dirname, '..', 'index.js');
+
+  log(`Rebasing ${fmt.branch(`mission/${slug}`)} onto the latest primary branch before reviewer launch...`);
+
+  const result = runFn(process.execPath, [workflowCli, 'rebase', slug, '--push'], {
+    cwd: worktree,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+  const output = [result.stdout, result.stderr].filter(Boolean).join('\n').trim();
+
+  if (result.status === 0) {
+    log(fmt.status('PASS', `Pre-review rebase completed for ${fmt.branch(`mission/${slug}`)}.`));
+    return { ok: true, sharedFileConflicts: false };
+  }
+
+  if (output) {
+    error(output);
+  }
+  const sharedFileConflicts = SHARED_FILE_REBASE_CONFLICT_RE.test(output);
+  if (sharedFileConflicts) {
+    error(fmt.status('FAIL', 'Shared-file rebase conflicts detected. Autonomous review loop cannot continue safely.'));
+    log(fmt.status('INFO', `Resolve the conflicts in the worktree, then re-run: px review ${slug} --start`));
+  } else {
+    error(fmt.status('FAIL', `Rebase failed before launching reviewer for ${fmt.branch(`mission/${slug}`)}.`));
+  }
+  return { ok: false, sharedFileConflicts };
+}
+
+module.exports = {
+  commitSafeMissionArtifacts,
+  rebaseBeforeReviewRound,
+};

package/lib/review/review-adapter.js

@@ -0,0 +1,135 @@
+/**
+ * Review Adapter
+ *
+ * This module is the only review-facing provider boundary. Review code calls
+ * this adapter instead of importing Forgejo or product-config directly.
+ */
+
+const os = require('os');
+const path = require('path');
+const { resolveReviewAdapter, isForgejoReviewEnabled } = require('../core/product-config');
+const { loadAdapterConfig } = require('../core/product-config');
+const forgejo = require('../tools/forgejo');
+
+const NOOP_PR_STATUS = Object.freeze({
+  exists: false,
+  raw: 'Forgejo PR: skipped (review provider is not forgejo).',
+});
+
+function getReviewProvider(rootDir = process.cwd()) {
+  return resolveReviewAdapter(rootDir).provider || null;
+}
+
+function isEnabled(rootDir = process.cwd()) {
+  return isForgejoReviewEnabled(rootDir);
+}
+
+function isProviderEnabled(rootDir = process.cwd()) {
+  return isEnabled(rootDir);
+}
+
+function isNoop(rootDir = process.cwd()) {
+  const provider = getReviewProvider(rootDir);
+  return provider === null || provider === 'none';
+}
+
+function isForgejoProvider(rootDir = process.cwd()) {
+  return isEnabled(rootDir);
+}
+
+function resolveArtifactDir(rootDir = process.cwd()) {
+  const review = loadAdapterConfig(rootDir).review || {};
+  const configured = typeof review.tmpDir === 'string' && review.tmpDir.trim()
+    ? review.tmpDir.trim()
+    : null;
+  if (!configured) {
+    return os.tmpdir();
+  }
+  return path.isAbsolute(configured) ? configured : path.resolve(rootDir, configured);
+}
+
+function withForgejo(rootDir, liveFn, noopValue) {
+  return isEnabled(rootDir) ? liveFn() : noopValue;
+}
+
+function getPrStatus(branch, rootDir = process.cwd(), options = {}) {
+  return withForgejo(rootDir, () => forgejo.getPrStatus(branch, rootDir, options), NOOP_PR_STATUS);
+}
+
+function readToken(user, options = {}) {
+  const rootDir = options.rootDir || process.cwd();
+  return isEnabled(rootDir) ? forgejo.readToken(user) : null;
+}
+
+async function getLatestReviewForPr(prNumber, reviewerUser, sinceIso, token, options = {}) {
+  if (!token) return null;
+  return withForgejo(options.rootDir || process.cwd(), () => forgejo.getLatestReviewForPr(prNumber, reviewerUser, sinceIso, token, options), null);
+}
+
+async function getLatestDispositionForPr(prNumber, implementerUser, sinceIso, token, options = {}) {
+  if (!token) return null;
+  return withForgejo(options.rootDir || process.cwd(), () => forgejo.getLatestDispositionForPr(prNumber, implementerUser, sinceIso, token, options), null);
+}
+
+function postComment(branch, token, body, options = {}) {
+  return withForgejo(options.rootDir || process.cwd(), () => forgejo.postComment(branch, token, body, options), { ok: true, skipped: true, reason: 'review-provider-disabled' });
+}
+
+function postReview(branch, token, outcome, summary, options = {}) {
+  return withForgejo(options.rootDir || process.cwd(), () => forgejo.postReview(branch, token, outcome, summary, options), { ok: true, skipped: true, reason: 'review-provider-disabled' });
+}
+
+function createPr(branch, user, token, options = {}) {
+  return withForgejo(options.rootDir || process.cwd(), () => forgejo.createPr(branch, user, token, options), { ok: true, skipped: true, url: null });
+}
+
+function forgejoAvailable(url = process.env.FORGEJO_URL || 'http://localhost:3300', options = {}) {
+  return withForgejo(options.rootDir || process.cwd(), () => forgejo.forgejoAvailable(url, options), false);
+}
+
+function providerAvailable(url = process.env.FORGEJO_URL || 'http://localhost:3300', options = {}) {
+  return forgejoAvailable(url, options);
+}
+
+async function getComments(branch, token, options = {}) {
+  return withForgejo(options.rootDir || process.cwd(), () => forgejo.getComments(branch, token, options), []);
+}
+
+function closePr(branch, token, user, options = {}) {
+  return withForgejo(options.rootDir || process.cwd(), () => forgejo.closePr(branch, token, user, options), { ok: true, skipped: true, reason: 'review-provider-disabled' });
+}
+
+function resolveForgejoUser(explicitUser) {
+  return explicitUser || process.env.FORGEJO_USER || null;
+}
+
+function resolveReviewUser(explicitUser) {
+  return resolveForgejoUser(explicitUser);
+}
+
+function getPrAuthor(branch, token, options = {}) {
+  return withForgejo(options.rootDir || process.cwd(), () => forgejo.getPrAuthor(branch, token, options), null);
+}
+
+module.exports = {
+  getReviewProvider,
+  isEnabled,
+  isProviderEnabled,
+  isNoop,
+  isForgejoProvider,
+  resolveArtifactDir,
+  getPrStatus,
+  readToken,
+  getLatestReviewForPr,
+  getLatestDispositionForPr,
+  postComment,
+  postReview,
+  createPr,
+  forgejoAvailable,
+  providerAvailable,
+  getComments,
+  closePr,
+  resolveForgejoUser,
+  resolveReviewUser,
+  getPrAuthor,
+};