@jokerized/getresearchdone 0.4.1

package/lib/wireup/autofix.ts

@@ -0,0 +1,241 @@
+'use strict';
+
+/**
+ * GRD Wireup -- Auto-fix capability with confidence gating and re-run verification
+ *
+ * Provides infrastructure to automatically fix high-confidence missing connections
+ * detected by the wireup detection engine. Low and medium confidence issues are
+ * routed to a manual review list rather than risking incorrect automated changes.
+ *
+ * Fix application is delegated to the wireup orchestrator (which spawns a sonnet-tier
+ * subagent). autoFixIssue() returns the fix prompt and metadata; it does NOT spawn
+ * subprocesses directly.
+ *
+ * Model ceiling: SONNET_MODEL imported from ./state — never opus-class.
+ *
+ * @dependencies ./types, ./state
+ */
+
+import type { MissingConnection, FixAttempt, AutoFixResult } from './types';
+
+const {
+  SONNET_MODEL,
+  readWireupState,
+  writeWireupState,
+}: {
+  SONNET_MODEL: string;
+  readWireupState: (cwd: string) => import('./types').WireupState | null;
+  writeWireupState: (cwd: string, state: import('./types').WireupState) => void;
+} = require('./state');
+
+// ─── Model Alias ─────────────────────────────────────────────────────────────
+
+/**
+ * Model used for all wireup auto-fix subagent spawns.
+ * Aliased from SONNET_MODEL — do not redeclare.
+ */
+const WIREUP_FIX_MODEL: string = SONNET_MODEL;
+
+// ─── Confidence Classification ────────────────────────────────────────────────
+
+/**
+ * Classify the fix confidence for a given MissingConnection.
+ *
+ * High confidence (safe to auto-fix):
+ *   missing-import, missing-export — single-line addition to a known file
+ *   missing-route — route registration is a mechanical single-line change
+ *
+ * Medium confidence (may require understanding of app structure):
+ *   unconnected-handler, missing-middleware
+ *
+ * Low confidence (may require external config or user input):
+ *   broken-nav-link, missing-env-var
+ *
+ * The returned value reflects the confidence of the *fix* action, not the
+ * detection confidence stored on the issue itself.
+ */
+function classifyFixConfidence(issue: MissingConnection): 'high' | 'medium' | 'low' {
+  switch (issue.issue_type) {
+    case 'missing-import':
+    case 'missing-export':
+    case 'missing-route':
+      return 'high';
+    case 'unconnected-handler':
+    case 'missing-middleware':
+      return 'medium';
+    case 'broken-nav-link':
+    case 'missing-env-var':
+      return 'low';
+    default: {
+      // Exhaustiveness guard — TypeScript will catch unhandled cases at compile time
+      const _exhaustive: never = issue.issue_type;
+      void _exhaustive;
+      return 'low';
+    }
+  }
+}
+
+// ─── Fix Prompt Builder ───────────────────────────────────────────────────────
+
+/**
+ * Build a structured prompt for a sonnet-tier agent to apply the minimal fix
+ * for a given MissingConnection.
+ *
+ * The prompt instructs the agent to:
+ *   1. Read the source and target files
+ *   2. Apply the minimal fix (add import, register route, add export)
+ *   3. Commit with message: wireup: fix <description>
+ */
+function buildAutoFixPrompt(issue: MissingConnection): string {
+  return [
+    `You are applying a minimal code fix to resolve a missing connection.`,
+    ``,
+    `Issue type: ${issue.issue_type}`,
+    `Source file: ${issue.source_file}`,
+    `Target file: ${issue.target_file}`,
+    ``,
+    `Suggested fix:`,
+    issue.suggested_fix,
+    ``,
+    `Instructions:`,
+    `1. Read both the source file and the target file.`,
+    `2. Apply the minimal fix described above. Do not refactor any existing code.`,
+    `   Add only what is needed to resolve the missing connection.`,
+    `3. Commit your change with the message: wireup: fix ${issue.issue_type} in ${issue.target_file}`,
+    ``,
+    `Do not make any changes beyond what is described in the suggested fix.`,
+  ].join('\n');
+}
+
+// ─── Auto-Fix Attempt ─────────────────────────────────────────────────────────
+
+/**
+ * Attempt to auto-fix a single MissingConnection.
+ *
+ * Confidence gate: if issue.confidence !== 'high', returns immediately with
+ * fix_status 'skipped' — reRunFn is never called.
+ *
+ * For high-confidence issues:
+ *   - Returns the fix prompt and metadata for the orchestrator to act on.
+ *   - The orchestrator spawns a sonnet-tier subagent using the prompt, then calls
+ *     reRunFn() to verify the fix.
+ *   - fix_status is 'verified' if reRunFn returns true, 'failed' otherwise.
+ *
+ * @param _cwd    Working directory (reserved for future state integration)
+ * @param issue   The missing connection to fix
+ * @param reRunFn Callback that re-runs the failed scenario; returns true if it now passes
+ */
+async function autoFixIssue(
+  _cwd: string,
+  issue: MissingConnection,
+  reRunFn: () => Promise<boolean>
+): Promise<FixAttempt> {
+  // Confidence gate — only high-confidence issues are auto-fixed
+  if (issue.confidence !== 'high') {
+    return {
+      issue,
+      fix_status: 'skipped',
+    };
+  }
+
+  const fixDescription = `${issue.issue_type} in ${issue.target_file}`;
+
+  try {
+    // Build fix prompt for orchestrator to pass to the sonnet-tier subagent
+    const fixPrompt = buildAutoFixPrompt(issue);
+
+    const rerunPassed = await reRunFn();
+
+    return {
+      issue,
+      fix_status: rerunPassed ? 'verified' : 'failed',
+      fix_description: fixDescription,
+      rerun_passed: rerunPassed,
+      fix_prompt: fixPrompt,
+    };
+  } catch (err: unknown) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    return {
+      issue,
+      fix_status: 'failed',
+      fix_description: fixDescription,
+      rerun_passed: false,
+      error: errorMessage,
+    };
+  }
+}
+
+// ─── Partition by Confidence ──────────────────────────────────────────────────
+
+/**
+ * Split a list of issues into two groups:
+ *   - High-confidence issues (candidates for auto-fix)
+ *   - Medium and low confidence issues (manual review required)
+ *
+ * Returns an AutoFixResult with fixes_applied initially empty (populated by the
+ * orchestrator after running autoFixIssue on each high-confidence issue) and
+ * requires_manual_review pre-populated with non-high-confidence issues.
+ */
+function partitionByConfidence(issues: MissingConnection[]): AutoFixResult & { high_confidence: MissingConnection[] } {
+  const requiresManualReview: MissingConnection[] = [];
+  const highConfidenceIssues: MissingConnection[] = [];
+
+  for (const issue of issues) {
+    if (issue.confidence === 'high') {
+      highConfidenceIssues.push(issue);
+    } else {
+      requiresManualReview.push(issue);
+    }
+  }
+
+  return {
+    fixes_applied: [],
+    requires_manual_review: requiresManualReview,
+    high_confidence: highConfidenceIssues,
+    model_used: WIREUP_FIX_MODEL,
+  };
+}
+
+// ─── Fix Outcome Persistence ──────────────────────────────────────────────────
+
+/**
+ * Persist a fix attempt outcome to wireup state.
+ *
+ * Reads WIREUP-STATE.json, appends to fixes_applied counter,
+ * then writes the updated state back to disk.
+ *
+ * No-op if the state file does not exist (graceful degradation).
+ *
+ * @param cwd        Working directory containing .planning/WIREUP-STATE.json
+ * @param _scenarioId Scenario ID associated with the fix (for future indexing)
+ * @param fixAttempt  The FixAttempt to record
+ */
+function updateFixOutcome(
+  cwd: string,
+  _scenarioId: string,
+  fixAttempt: FixAttempt
+): void {
+  const state = readWireupState(cwd);
+  if (state === null) return;
+
+  // Only increment fixes_applied for successful (verified) fixes
+  const delta = fixAttempt.fix_status === 'verified' ? 1 : 0;
+
+  const updatedState = {
+    ...state,
+    fixes_applied: state.fixes_applied + delta,
+    timestamp: new Date().toISOString(),
+  };
+
+  writeWireupState(cwd, updatedState);
+}
+
+// ─── Exports ──────────────────────────────────────────────────────────────────
+
+module.exports = {
+  classifyFixConfidence,
+  buildAutoFixPrompt,
+  autoFixIssue,
+  partitionByConfidence,
+  updateFixOutcome,
+};

package/lib/wireup/cli.ts

@@ -0,0 +1,278 @@
+'use strict';
+
+/**
+ * GRD Wireup -- CLI command functions
+ *
+ * Provides:
+ *   - cmdInitWireup: pre-flight context builder for /grd:wireup slash command
+ *   - cmdWireupDiscover: discover unwired features via filesystem analysis
+ *   - cmdWireupRun: MCP wrapper — runs wireup and outputs JSON only (no human summary)
+ *   - cmdWireupState: read current wireup iteration state
+ *   - cmdWireupScenarios: list generated wireup scenarios
+ *   - cmdWireupReport: get the latest WIREUP-REPORT.md content
+ *
+ * Follows the cmdInitEvolve / cmdEvolveDiscover / cmdEvolveState patterns
+ * from lib/evolve/cli.ts.
+ *
+ * @dependencies ./types, ./state, ./discovery, ./scenarios, ./orchestrator, ./report,
+ *               ../utils, ../backend, ../paths
+ */
+
+import type { WireupState, UnwiredFeature, WireupScenario, WireupOptions } from './types';
+import type { BackendCapabilities, GrdConfig, MilestoneInfo } from '../types';
+
+const fs = require('fs');
+
+const {
+  SONNET_MODEL,
+  readWireupState,
+}: {
+  SONNET_MODEL: string;
+  readWireupState: (cwd: string) => WireupState | null;
+} = require('./state');
+
+const {
+  discoverUnwiredFeatures,
+}: {
+  discoverUnwiredFeatures: (cwd: string) => UnwiredFeature[];
+} = require('./discovery');
+
+const {
+  generateScenarios,
+}: {
+  generateScenarios: (features: UnwiredFeature[], cwd: string) => WireupScenario[];
+} = require('./scenarios');
+
+const {
+  runWireup,
+}: {
+  runWireup: (cwd: string, options?: WireupOptions) => Promise<import('./types').WireupResult>;
+} = require('./orchestrator');
+
+const {
+  formatReportPath,
+}: {
+  formatReportPath: (cwd: string) => string;
+} = require('./report');
+
+const {
+  loadConfig,
+  resolveModelForAgent,
+  getMilestoneInfo,
+  output,
+}: {
+  loadConfig: (cwd: string) => GrdConfig;
+  resolveModelForAgent: (config: GrdConfig, agent: string, cwd: string) => string;
+  getMilestoneInfo: (cwd: string) => MilestoneInfo;
+  output: (result: unknown, raw: boolean, rawValue?: unknown) => never;
+} = require('../utils');
+
+const {
+  detectBackend,
+  getBackendCapabilities,
+}: {
+  detectBackend: (cwd: string) => string;
+  getBackendCapabilities: (backend: string) => BackendCapabilities;
+} = require('../backend');
+
+const {
+  planningDir: getPlanningDir,
+}: {
+  planningDir: (cwd: string) => string;
+} = require('../paths');
+
+// ─── Context Builder ──────────────────────────────────────────────────────────
+
+/**
+ * Pre-flight context builder for the /grd:wireup slash command.
+ *
+ * Returns a JSON bundle containing backend, capabilities, models, wireup state,
+ * milestone info, and wireup_dir — mirroring the cmdInitEvolve pattern.
+ */
+function cmdInitWireup(cwd: string, raw: boolean): void {
+  const config: GrdConfig = loadConfig(cwd);
+  const backend: string = detectBackend(cwd);
+  const capabilities: BackendCapabilities = getBackendCapabilities(backend);
+  const wireupState: WireupState | null = readWireupState(cwd);
+  const executorModel: string = resolveModelForAgent(config, 'grd-executor', cwd);
+  const milestone: MilestoneInfo = getMilestoneInfo(cwd);
+  const wireupDir: string = getPlanningDir(cwd);
+
+  const result = {
+    backend,
+    capabilities,
+    sonnet_model: SONNET_MODEL,
+    models: {
+      executor: executorModel,
+    },
+    config: {
+      model_profile: config.model_profile || 'balanced',
+      autonomous_mode: config.autonomous_mode || false,
+    },
+    wireup_state: wireupState
+      ? {
+          exists: true,
+          features_discovered: wireupState.features_discovered,
+          scenarios_generated: wireupState.scenarios_generated,
+          scenarios_passed: wireupState.scenarios_passed,
+          scenarios_failed: wireupState.scenarios_failed,
+          fixes_applied: wireupState.fixes_applied,
+          iteration_count: wireupState.iteration_history.length,
+          milestone: wireupState.milestone,
+          timestamp: wireupState.timestamp,
+        }
+      : { exists: false },
+    milestone,
+    wireup_dir: wireupDir,
+  };
+
+  output(result, raw, raw ? JSON.stringify(result) : undefined);
+  // Unreachable — output() calls process.exit()
+}
+
+// ─── Sub-Command Wrappers ─────────────────────────────────────────────────────
+
+/**
+ * Discover unwired features in the project via filesystem analysis.
+ * Outputs a list of features grouped by category (exported-but-uncalled,
+ * config-without-surface, endpoint-without-integration-test).
+ */
+function cmdWireupDiscover(cwd: string, _args: string[], raw: boolean): unknown {
+  const features: UnwiredFeature[] = discoverUnwiredFeatures(cwd);
+
+  const byCategory: Record<string, number> = {};
+  for (const f of features) {
+    byCategory[f.category] = (byCategory[f.category] ?? 0) + 1;
+  }
+
+  const out = {
+    features_found: features.length,
+    by_category: byCategory,
+    features: features.map((f) => ({
+      category: f.category,
+      function_name: f.functionName,
+      file_path: f.filePath,
+      suggested_action: f.suggestedAction,
+    })),
+  };
+
+  output(out, raw, raw ? `${features.length} unwired features discovered` : undefined);
+  // Unreachable — output() calls process.exit()
+  return undefined as never;
+}
+
+/**
+ * Run a full wireup iteration via MCP — thin wrapper around runWireup().
+ *
+ * Unlike cmdWireup (orchestrator.ts) which prints a human-readable summary,
+ * this outputs only structured JSON — suitable for MCP tool responses.
+ */
+async function cmdWireupRun(cwd: string, args: string[], raw: boolean): Promise<unknown> {
+  const parsedOptions: WireupOptions = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--target' && args[i + 1]) parsedOptions.target = args[++i];
+    else if (arg === '--dry-run') parsedOptions.dryRun = true;
+    else if (arg === '--timeout' && args[i + 1]) {
+      const t = parseInt(args[++i], 10);
+      if (!isNaN(t)) parsedOptions.timeout = t;
+    } else if (arg === '--max-turns' && args[i + 1]) {
+      const mt = parseInt(args[++i], 10);
+      if (!isNaN(mt)) parsedOptions.maxTurns = mt;
+    }
+  }
+  const result = await runWireup(cwd, parsedOptions);
+  output(result, raw, raw ? result.pass_fail_summary : undefined);
+  return undefined as never;
+}
+
+/**
+ * Read the current wireup iteration state (features discovered, scenarios, fixes applied).
+ */
+function cmdWireupState(cwd: string, _args: string[], raw: boolean): void {
+  const state: WireupState | null = readWireupState(cwd);
+
+  if (state === null) {
+    const out = { exists: false, state: null };
+    output(out, raw, raw ? 'No wireup state found' : undefined);
+  } else {
+    const out = { exists: true, state };
+    output(out, raw, raw ? JSON.stringify(state) : undefined);
+  }
+  // Unreachable — output() calls process.exit()
+}
+
+/**
+ * List generated wireup scenarios for discovered features.
+ *
+ * Reads persisted state first; falls back to live discovery only if no state exists.
+ */
+function cmdWireupScenarios(cwd: string, _args: string[], raw: boolean): void {
+  const state = readWireupState(cwd);
+
+  if (state !== null) {
+    const out = {
+      scenarios_count: state.scenarios_generated,
+      features_count: state.features_discovered,
+      source: 'cached' as const,
+      milestone: state.milestone,
+    };
+    output(out, raw, raw ? `${state.scenarios_generated} scenarios for ${state.features_discovered} features (cached)` : undefined);
+    return; // Unreachable — output() calls process.exit()
+  }
+
+  const features: UnwiredFeature[] = discoverUnwiredFeatures(cwd);
+  const scenarios: WireupScenario[] = generateScenarios(features, cwd);
+
+  const out = {
+    scenarios_count: scenarios.length,
+    features_count: features.length,
+    source: 'live' as const,
+    scenarios: scenarios.map((s) => ({
+      feature_function: s.feature.functionName,
+      feature_file: s.feature.filePath,
+      category: s.feature.category,
+      steps_count: s.steps.length,
+      test_data_fixture: s.test_data_fixture,
+    })),
+  };
+
+  output(out, raw, raw ? `${scenarios.length} scenarios for ${features.length} features` : undefined);
+  // Unreachable — output() calls process.exit()
+}
+
+/**
+ * Get the latest wireup report with pass/fail results and issue summary.
+ *
+ * Reads WIREUP-REPORT.md from the current milestone wireup directory.
+ */
+function cmdWireupReport(cwd: string, _args: string[], raw: boolean): void {
+  const reportPath: string = formatReportPath(cwd);
+
+  let reportContent: string | null = null;
+  try {
+    reportContent = fs.readFileSync(reportPath, 'utf8') as string;
+  } catch {
+    // Report doesn't exist yet
+  }
+
+  if (reportContent === null) {
+    const out = { exists: false, report_path: reportPath, content: null };
+    output(out, raw, raw ? 'No wireup report found' : undefined);
+  } else {
+    const out = { exists: true, report_path: reportPath, content: reportContent };
+    output(out, raw, raw ? reportContent : undefined);
+  }
+  // Unreachable — output() calls process.exit()
+}
+
+// ─── Exports ────────────────────────────────────────────────────────────────
+
+module.exports = {
+  cmdInitWireup,
+  cmdWireupDiscover,
+  cmdWireupRun,
+  cmdWireupState,
+  cmdWireupScenarios,
+  cmdWireupReport,
+};