dual-brain 0.2.4 → 0.2.5

package/src/health.mjs

@@ -314,6 +314,41 @@ export function resetHealth(cwd) {
   saveRaw({ states: {}, session: null }, cwd);
 }
 
+// ─── Network timeout guard ────────────────────────────────────────────────────
+
+/**
+ * Ping a provider URL with a bounded timeout so slow networks don't hang the CLI.
+ *
+ * Uses AbortController to enforce the deadline.  On timeout or network error the
+ * caller receives { ok: false, status: 'timeout' } rather than hanging forever.
+ *
+ * @param {string} url
+ * @param {{ timeoutMs?: number, headers?: Record<string,string> }} [opts]
+ * @returns {Promise<{ ok: boolean, status: 'ok'|'timeout'|'error', detail?: string }>}
+ */
+export async function pingProvider(url, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 5000;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, {
+      method: 'HEAD',
+      signal: controller.signal,
+      headers: opts.headers ?? {},
+    });
+    clearTimeout(timer);
+    return { ok: res.ok, status: 'ok', detail: String(res.status) };
+  } catch (err) {
+    clearTimeout(timer);
+    const isTimeout = err?.name === 'AbortError';
+    return {
+      ok: false,
+      status: isTimeout ? 'timeout' : 'error',
+      detail: isTimeout ? `Provider health: unknown (timeout after ${timeoutMs}ms)` : String(err?.message),
+    };
+  }
+}
+
 // ─── Remaining cooldown helper (used by status display) ──────────────────────
 
 /**

package/src/pipeline.mjs

@@ -84,6 +84,9 @@ export function createPipelineRun(trigger = '', prompt = '') {
     replitTools: null,       // from replit.inspectReplitTools()
     replitConfig: null,      // from replit.getReplitToolsConfig()
 
+    // Execution safety (populated in Phase 3 when risk is high/critical)
+    checkpoint: null,        // from checkpoint.mjs — { success, id, label, timestamp } or null
+
     completedAt: null,
   };
 }
@@ -978,11 +981,28 @@ export async function runPipeline(trigger, prompt, options = {}) {
 
     // ── Phase 3: Execute ──────────────────────────────────────────────────────
 
-    // Checkpoint (best-effort, before execute)
+    // Checkpoint (best-effort, before execute).
+    // The pipeline-internal createCheckpoint handles git stash/HEAD recording.
+    // Additionally, use the dedicated checkpoint.mjs module for high/critical risk
+    // tasks so the result is surfaced in the run object.
     if (run.plan.checkpointRequired) {
       await createCheckpoint(cwd, run.context);
     }
 
+    const detectedRisk = run.context?.detection?.risk ?? 'low';
+    if (detectedRisk === 'high' || detectedRisk === 'critical') {
+      try {
+        const { createCheckpoint: cpCreate } = await import('./checkpoint.mjs');
+        const cpLabel = `before: ${prompt.slice(0, 80)}`;
+        const cpResult = cpCreate(cpLabel, { cwd });
+        run.checkpoint = cpResult;
+        if (verbose) log(`[pipeline] checkpoint created: ${cpResult.id} (${cpResult.success ? 'ok' : 'failed'})`);
+      } catch {
+        // checkpoint.mjs unavailable — non-blocking
+        run.checkpoint = null;
+      }
+    }
+
     const decision = { ...run.plan._decision };
 
     run.result = await dispatch({
@@ -1157,6 +1177,41 @@ export async function runPipeline(trigger, prompt, options = {}) {
       }
     }
 
+    // Continuity handoff — generate and persist a compact receipt so the next
+    // session can resume seamlessly (survives context limits and crashes).
+    try {
+      const { generateHandoff, saveHandoff, pruneHandoffs } = await import('./continuity.mjs');
+      const handoffCwd = options.cwd || process.cwd();
+
+      const sessionState = {
+        taskDescription: prompt.slice(0, 200),
+        filesChanged: run.result?.filesChanged || run.plan?.targetFiles || [],
+        testsRun: run.verification?.notes || [],
+        decisions: run.plan ? [{
+          provider: run.plan.primaryProvider,
+          model: run.plan.primaryModel,
+          tier: run.plan.tier,
+          reasoningDepth: run.plan.reasoningDepth,
+        }] : [],
+        unresolved: run.contradictions?.filter(c => c.severity !== 'block').map(c => c.message) || [],
+        routingHistory: {
+          lastProvider: run.result?.provider || run.plan?.primaryProvider || null,
+          lastModel: run.result?.model || run.plan?.primaryModel || null,
+          failedProviders: run.result?.error ? [run.plan?.primaryProvider].filter(Boolean) : [],
+        },
+        activePreferences: run.context?.profile?.preferences || [],
+        resumeHint: run.result && !run.result?.error
+          ? null
+          : `retry: ${prompt.slice(0, 100)}`,
+      };
+
+      const handoff = generateHandoff(sessionState);
+      saveHandoff(handoff, handoffCwd);
+      pruneHandoffs(handoffCwd, 10); // keep last 10 handoffs
+    } catch {
+      // continuity is best-effort — never block pipeline completion
+    }
+
   } catch (err) {
     log(`[pipeline] error in pipeline step: ${err.message}`);
     run.result = { status: 'error', error: err.message };
@@ -1180,6 +1235,8 @@ export async function runPipeline(trigger, prompt, options = {}) {
     modelSuggestion: run.modelSuggestion,
     thinkResult: run.thinkResult,
     decisionPreflight: run.decisionPreflight,
+    // Execution safety
+    checkpoint: run.checkpoint,
     // Legacy compatibility
     plan: run.plan,
     result: run.result,

package/src/pr-agent.mjs

@@ -0,0 +1,214 @@
+// pr-agent.mjs — PR workflow module for dual-brain.
+// Provides issue/task → branch → implement → PR automation using the gh CLI.
+// Exports: hasGitHub, getBranchInfo, createBranch, getDiffSummary, createPR,
+//          listPRs, getPRDetails, buildPRBody
+
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * Check if gh CLI is available and authenticated.
+ * @returns {{ available: boolean, authenticated: boolean }}
+ */
+export function hasGitHub() {
+  try {
+    execSync('gh auth status', { stdio: 'pipe', timeout: 5000 });
+    return { available: true, authenticated: true };
+  } catch {
+    try {
+      execSync('which gh', { stdio: 'pipe', timeout: 2000 });
+      return { available: true, authenticated: false };
+    } catch {
+      return { available: false, authenticated: false };
+    }
+  }
+}
+
+/**
+ * Get current branch info including distance from default branch.
+ * @param {string} [cwd]
+ * @returns {{ branch: string|null, defaultBranch: string, ahead: number, behind: number, isDefault: boolean }}
+ */
+export function getBranchInfo(cwd) {
+  const dir = cwd ?? process.cwd();
+  try {
+    const branch = execSync('git rev-parse --abbrev-ref HEAD', { cwd: dir, encoding: 'utf8', timeout: 3000 }).trim();
+    const defaultBranch = execSync(
+      'git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null || echo refs/remotes/origin/main',
+      { cwd: dir, encoding: 'utf8', timeout: 3000 },
+    ).trim().replace('refs/remotes/origin/', '');
+    const ahead = parseInt(
+      execSync(`git rev-list --count ${defaultBranch}..HEAD 2>/dev/null || echo 0`, { cwd: dir, encoding: 'utf8', timeout: 3000 }).trim(),
+    ) || 0;
+    const behind = parseInt(
+      execSync(`git rev-list --count HEAD..${defaultBranch} 2>/dev/null || echo 0`, { cwd: dir, encoding: 'utf8', timeout: 3000 }).trim(),
+    ) || 0;
+    return { branch, defaultBranch, ahead, behind, isDefault: branch === defaultBranch };
+  } catch {
+    return { branch: null, defaultBranch: 'main', ahead: 0, behind: 0, isDefault: true };
+  }
+}
+
+/**
+ * Create a feature branch from a task description.
+ * Branch name is prefixed with "db/" and slugified from the description.
+ * @param {string} taskDescription
+ * @param {string} [cwd]
+ * @returns {{ success: boolean, branch: string, error?: string }}
+ */
+export function createBranch(taskDescription, cwd) {
+  const dir = cwd ?? process.cwd();
+  const slug = taskDescription
+    .toLowerCase()
+    .replace(/[^a-z0-9\s-]/g, '')
+    .trim()
+    .replace(/\s+/g, '-')
+    .slice(0, 50);
+  const branchName = `db/${slug}`;
+
+  try {
+    execSync(`git checkout -b "${branchName}"`, { cwd: dir, stdio: 'pipe', timeout: 5000 });
+    return { success: true, branch: branchName };
+  } catch (err) {
+    return { success: false, branch: branchName, error: err.message };
+  }
+}
+
+/**
+ * Get diff summary for PR description generation.
+ * @param {string} baseBranch  Base branch name (e.g. 'main')
+ * @param {string} [cwd]
+ * @returns {{ stat: string, files: string[], summary: string, fileCount: number }}
+ */
+export function getDiffSummary(baseBranch, cwd) {
+  const dir = cwd ?? process.cwd();
+  try {
+    const stat = execSync(`git diff --stat ${baseBranch}...HEAD`, { cwd: dir, encoding: 'utf8', timeout: 10000 }).trim();
+    const files = execSync(`git diff --name-only ${baseBranch}...HEAD`, { cwd: dir, encoding: 'utf8', timeout: 5000 })
+      .trim()
+      .split('\n')
+      .filter(Boolean);
+    const summary = execSync(`git diff --shortstat ${baseBranch}...HEAD`, { cwd: dir, encoding: 'utf8', timeout: 5000 }).trim();
+    return { stat, files, summary, fileCount: files.length };
+  } catch {
+    return { stat: '', files: [], summary: '', fileCount: 0 };
+  }
+}
+
+/**
+ * Create a PR using the gh CLI. Pushes the current branch first.
+ * @param {object} opts
+ * @param {string} opts.title
+ * @param {string} opts.body
+ * @param {string} [opts.baseBranch]
+ * @param {boolean} [opts.draft]
+ * @param {string[]} [opts.labels]
+ * @param {string} [opts.cwd]
+ * @returns {{ success: boolean, url?: string, error?: string }}
+ */
+export function createPR(opts) {
+  const { title, body, baseBranch, draft, labels, cwd } = opts;
+  const dir = cwd ?? process.cwd();
+
+  try {
+    // Push current branch to origin first
+    const branch = execSync('git rev-parse --abbrev-ref HEAD', { cwd: dir, encoding: 'utf8', timeout: 3000 }).trim();
+    execSync(`git push -u origin "${branch}"`, { cwd: dir, stdio: 'pipe', timeout: 30000 });
+
+    // Build gh pr create args
+    const args = ['gh', 'pr', 'create', '--title', JSON.stringify(title), '--body', JSON.stringify(body)];
+    if (baseBranch) args.push('--base', baseBranch);
+    if (draft) args.push('--draft');
+    if (labels?.length) args.push('--label', labels.join(','));
+
+    const result = execSync(args.join(' '), { cwd: dir, encoding: 'utf8', timeout: 30000 });
+    const url = result.trim();
+    return { success: true, url };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * List open (or other state) PRs for the current repo.
+ * @param {string} [cwd]
+ * @param {object} [opts]
+ * @param {'open'|'closed'|'merged'|'all'} [opts.state]
+ * @param {number} [opts.limit]
+ * @returns {object[]}
+ */
+export function listPRs(cwd, opts = {}) {
+  const dir = cwd ?? process.cwd();
+  const { state = 'open', limit = 10 } = opts;
+  try {
+    const json = execSync(
+      `gh pr list --state ${state} --limit ${limit} --json number,title,headRefName,author,createdAt,isDraft`,
+      { cwd: dir, encoding: 'utf8', timeout: 10000 },
+    );
+    return JSON.parse(json);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Get PR details including diff stats, comments, and CI checks.
+ * @param {number|string} prNumber
+ * @param {string} [cwd]
+ * @returns {object|null}
+ */
+export function getPRDetails(prNumber, cwd) {
+  const dir = cwd ?? process.cwd();
+  try {
+    const json = execSync(
+      `gh pr view ${prNumber} --json title,body,headRefName,baseRefName,state,additions,deletions,changedFiles,reviews,comments,statusCheckRollup`,
+      { cwd: dir, encoding: 'utf8', timeout: 10000 },
+    );
+    return JSON.parse(json);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Build a PR body from a task description and dispatch results.
+ * @param {string} taskDescription
+ * @param {object} results  Dispatch result object (filesChanged, testsRun, decisions, etc.)
+ * @returns {string}
+ */
+export function buildPRBody(taskDescription, results) {
+  const lines = [];
+  lines.push('## Summary');
+  lines.push(taskDescription);
+  lines.push('');
+
+  if (results.filesChanged?.length) {
+    lines.push('## Changes');
+    for (const f of results.filesChanged) {
+      lines.push(`- \`${f}\``);
+    }
+    lines.push('');
+  }
+
+  if (results.testsRun?.length) {
+    lines.push('## Tests');
+    for (const t of results.testsRun) {
+      lines.push(`- ${t}`);
+    }
+    lines.push('');
+  }
+
+  if (results.decisions?.length) {
+    lines.push('## Routing');
+    for (const d of results.decisions) {
+      lines.push(`- ${d}`);
+    }
+    lines.push('');
+  }
+
+  lines.push('---');
+  lines.push('Generated by [dual-brain](https://npmjs.com/package/dual-brain)');
+
+  return lines.join('\n');
+}

package/src/repo.mjs

@@ -283,6 +283,159 @@ export function getLintCommand(cwd = process.cwd()) {
   return detectRepo(cwd).commands.lint;
 }
 
+// ─── Ownership hints ──────────────────────────────────────────────────────────
+
+/**
+ * Return the last git author, last-modified date, and commit count for a file.
+ * @param {string} filePath
+ * @param {string} [cwd]
+ * @returns {{ lastAuthor: string, lastModified: string, totalCommits: number }|null}
+ */
+export function getFileOwnership(filePath, cwd) {
+  try {
+    const blame = execSync(`git log --format="%an" -1 -- "${filePath}"`, { cwd, encoding: 'utf8', timeout: 5000 }).trim();
+    const lastDate = execSync(`git log --format="%ci" -1 -- "${filePath}"`, { cwd, encoding: 'utf8', timeout: 5000 }).trim();
+    const commitCount = parseInt(execSync(`git rev-list --count HEAD -- "${filePath}"`, { cwd, encoding: 'utf8', timeout: 5000 }).trim()) || 0;
+    return { lastAuthor: blame, lastModified: lastDate, totalCommits: commitCount };
+  } catch { return null; }
+}
+
+// ─── Dependency edges ─────────────────────────────────────────────────────────
+
+/**
+ * Extract import/require edges from a source file.
+ * @param {string} filePath  — relative path from cwd
+ * @param {string} [cwd]
+ * @returns {{ local: string[], external: string[], total: number }}
+ */
+export function getDependencyEdges(filePath, cwd) {
+  try {
+    const content = readFileSync(join(cwd || process.cwd(), filePath), 'utf8');
+    const imports = [];
+    // ES module imports
+    for (const match of content.matchAll(/import\s+.*?from\s+['"]([^'"]+)['"]/g)) {
+      imports.push(match[1]);
+    }
+    // Dynamic imports
+    for (const match of content.matchAll(/import\(['"]([^'"]+)['"]\)/g)) {
+      imports.push(match[1]);
+    }
+    // CommonJS requires
+    for (const match of content.matchAll(/require\(['"]([^'"]+)['"]\)/g)) {
+      imports.push(match[1]);
+    }
+    const local = imports.filter(i => i.startsWith('.') || i.startsWith('/'));
+    const external = imports.filter(i => !i.startsWith('.') && !i.startsWith('/'));
+    return { local, external, total: imports.length };
+  } catch { return { local: [], external: [], total: 0 }; }
+}
+
+// ─── Test mapping ─────────────────────────────────────────────────────────────
+
+/**
+ * Find test files whose name matches the source file's base name.
+ * @param {string} filePath
+ * @param {string} [cwd]
+ * @returns {string[]}
+ */
+export function findRelatedTests(filePath, cwd) {
+  const root = cwd || process.cwd();
+  const base = filePath.replace(/\.(mjs|js|ts|tsx|jsx)$/, '');
+  const name = base.split('/').pop();
+
+  const found = [];
+  try {
+    const allTests = execSync(
+      `find . -type f \\( -name "*.test.*" -o -name "*.spec.*" -o -path "*/tests/*" -o -path "*/test/*" -o -path "*/__tests__/*" \\) -not -path "*/node_modules/*"`,
+      { cwd: root, encoding: 'utf8', timeout: 5000 }
+    ).trim().split('\n').filter(Boolean);
+
+    for (const t of allTests) {
+      if (t.includes(name)) found.push(t.replace(/^\.\//, ''));
+    }
+  } catch {}
+
+  return found;
+}
+
+// ─── Risk hotspots ────────────────────────────────────────────────────────────
+
+/**
+ * Return the files with highest churn × complexity risk in the last N days.
+ * @param {string} [cwd]
+ * @param {{ days?: number, limit?: number }} [opts]
+ * @returns {Array<{ file: string, changeCount: number, lineCount: number, risk: number }>}
+ */
+export function getRiskHotspots(cwd, opts = {}) {
+  const { days = 30, limit = 10 } = opts;
+  const root = cwd || process.cwd();
+  try {
+    const since = new Date(Date.now() - days * 86400000).toISOString().split('T')[0];
+    const log = execSync(
+      `git log --since="${since}" --name-only --pretty=format: | sort | uniq -c | sort -rn | head -${limit * 2}`,
+      { cwd: root, encoding: 'utf8', timeout: 10000 }
+    ).trim();
+
+    const hotspots = [];
+    for (const line of log.split('\n').filter(Boolean)) {
+      const match = line.trim().match(/^(\d+)\s+(.+)$/);
+      if (match) {
+        const changeCount = parseInt(match[1]);
+        const file = match[2];
+        if (changeCount >= 3 && existsSync(join(root, file))) {
+          let lineCount = 0;
+          try {
+            lineCount = readFileSync(join(root, file), 'utf8').split('\n').length;
+          } catch {}
+          hotspots.push({ file, changeCount, lineCount, risk: changeCount * Math.log2(Math.max(lineCount, 1)) });
+        }
+      }
+    }
+
+    return hotspots.sort((a, b) => b.risk - a.risk).slice(0, limit);
+  } catch { return []; }
+}
+
+// ─── Primary language detection ───────────────────────────────────────────────
+
+function detectPrimaryLanguage(cwd) {
+  try {
+    const files = execSync(
+      'git ls-files --cached | grep -oE "\\.[a-zA-Z]+$" | sort | uniq -c | sort -rn | head -5',
+      { cwd, encoding: 'utf8', timeout: 5000 }
+    ).trim();
+    const match = files.split('\n')[0]?.trim().match(/^\d+\s+\.(.+)$/);
+    const ext = match?.[1];
+    const langMap = {
+      js: 'JavaScript', mjs: 'JavaScript', ts: 'TypeScript', tsx: 'TypeScript',
+      py: 'Python', rb: 'Ruby', go: 'Go', rs: 'Rust', java: 'Java',
+      kt: 'Kotlin', swift: 'Swift', cpp: 'C++', c: 'C',
+    };
+    return langMap[ext] || ext || 'unknown';
+  } catch { return 'unknown'; }
+}
+
+// ─── Repo intelligence ────────────────────────────────────────────────────────
+
+/**
+ * Return consolidated repo intelligence for routing decisions.
+ * @param {string} [cwd]
+ * @returns {object}
+ */
+export function getRepoIntelligence(cwd) {
+  const root = cwd || process.cwd();
+  const cache = loadRepoCache(root);
+  const hotspots = getRiskHotspots(root);
+
+  return {
+    ...cache,
+    hotspots,
+    hasTests: hotspots.some(h => h.file.includes('test')),
+    primaryLanguage: detectPrimaryLanguage(root),
+    repoSize: cache?.fileCount || 0,
+  };
+}
+
 // ─── CLI (direct invocation) ──────────────────────────────────────────────────
 
 const isMain = process.argv[1]?.endsWith('repo.mjs');