@jokerized/getresearchdone 0.4.1

package/lib/cli/tools.ts

@@ -0,0 +1,198 @@
+'use strict';
+
+const { execFileSync } = require('child_process') as typeof import('child_process');
+const { join } = require('path') as typeof import('path');
+const path = require('path') as typeof import('path');
+const fs = require('fs') as typeof import('fs');
+
+import type { ScanMode, ScanReport, RunScanOpts } from '../commands/scan';
+import type { ScanHit } from '../scan/types';
+import type { ResolveScanOpts } from './scan-dispatch';
+
+const { runScan } = require('../commands/scan') as {
+  runScan: (opts: RunScanOpts) => ScanReport;
+};
+const { resolveScanFiles } = require('./scan-dispatch') as {
+  resolveScanFiles: (opts: ResolveScanOpts) => string[];
+};
+
+/**
+ * Build the argument list for grd-tools.js delegation.
+ * Includes passthrough flags (unknown flags forwarded from CLI).
+ */
+export function buildToolArgs(
+  command: string,
+  subcommand: string | undefined,
+  extraArgs: string[],
+  jsonFlag: boolean,
+  passthrough: string[] = []
+): string[] {
+  const args: string[] = [command];
+  if (subcommand) args.push(subcommand);
+  args.push(...extraArgs);
+  args.push(...passthrough);
+  if (jsonFlag) args.push('--raw');
+  return args;
+}
+
+// ─── Scan command helper ───────────────────────────────────────────────────────
+
+/**
+ * In-process handler for `gd scan`. Parses flags, resolves files, runs
+ * the scanner, and formats output (JSON or human text).
+ */
+function _runScanCommand(
+  extraArgs: string[],
+  jsonFlag: boolean,
+  cwd: string
+): { exitCode: number; stdout: string; stderr: string } {
+  // Parse flags
+  let mode: ScanMode = 'staged';
+  let filePath: string | undefined;
+  let diffBase: string | undefined;
+  let injectionOnly = false;
+  let base64Only = false;
+
+  let i = 0;
+  while (i < extraArgs.length) {
+    const arg = extraArgs[i];
+    if (arg === '--file') {
+      mode = 'file';
+      filePath = extraArgs[++i];
+    } else if (arg === '--diff') {
+      mode = 'diff';
+      diffBase = extraArgs[++i];
+    } else if (arg === '--all') {
+      mode = 'all';
+    } else if (arg === '--injection-only') {
+      injectionOnly = true;
+    } else if (arg === '--base64-only') {
+      base64Only = true;
+    } else if (arg.startsWith('--')) {
+      return { exitCode: 2, stdout: '', stderr: `scan: unknown flag ${arg}\n` };
+    }
+    i++;
+  }
+
+  if (injectionOnly && base64Only) {
+    return {
+      exitCode: 2,
+      stdout: '',
+      stderr: 'scan: --injection-only and --base64-only are mutually exclusive\n',
+    };
+  }
+
+  // Resolve files
+  let files: string[];
+  try {
+    files = resolveScanFiles({ mode, cwd, filePath, diffBase });
+  } catch (err: unknown) {
+    return {
+      exitCode: 2,
+      stdout: '',
+      stderr: (err as Error).message + '\n',
+    };
+  }
+
+  // Resolve ignore file
+  const ignoreFilePath = (() => {
+    const p = path.join(cwd, '.prompt-injection-scanignore');
+    return fs.existsSync(p) ? p : null;
+  })();
+
+  // Run scan
+  const report = runScan({ mode, files, ignoreFilePath, injectionOnly, base64Only });
+
+  if (jsonFlag) {
+    return {
+      exitCode: report.exitCode,
+      stdout: JSON.stringify(report, null, 2) + '\n',
+      stderr: '',
+    };
+  }
+
+  // Human text output
+  const unignored = report.hits.filter((h: ScanHit) => !h.ignored);
+  const ignored = report.hits.filter((h: ScanHit) => h.ignored);
+  const N = report.scanned;
+
+  let stdout: string;
+  if (unignored.length === 0 && ignored.length === 0) {
+    stdout = `scan: clean — ${N} file(s) checked\n`;
+  } else if (unignored.length === 0) {
+    stdout = `scan: clean — ${N} file(s) checked (${ignored.length} ignored hit(s))\n`;
+  } else {
+    const lines: string[] = [`scan: ${unignored.length} hit(s) in ${N} file(s)`];
+    for (const h of unignored) {
+      lines.push(`  ${h.file}:${h.line}  [${h.source}] ${h.label} → ${h.match}`);
+    }
+    stdout = lines.join('\n') + '\n';
+  }
+
+  return { exitCode: report.exitCode, stdout, stderr: '' };
+}
+
+/**
+ * Execute a tool command. Scan is handled in-process; all other commands
+ * delegate to grd-tools.js.
+ * TODO: Refactor to in-process delegation once output()/error() return values instead of process.exit().
+ */
+export function runToolCommand(
+  command: string,
+  subcommand: string | undefined,
+  extraArgs: string[],
+  jsonFlag: boolean,
+  cwd: string,
+  passthrough: string[] = []
+): { exitCode: number; stdout: string; stderr: string } {
+  // In-process dispatch for scan
+  if (command === 'scan') {
+    return _runScanCommand([...extraArgs, ...passthrough], jsonFlag, cwd);
+  }
+
+  const args = buildToolArgs(command, subcommand, extraArgs, jsonFlag, passthrough);
+  const grdTools = join(__dirname, '..', '..', 'bin', 'grd-tools.js');
+
+  // Codex r24 P2: live/follow commands need streaming stdio. execFileSync
+  // buffers stdout until child exits, so `gd tail --follow` and `gd watch`
+  // appear hung. Detect these cases and use spawnSync with inherited
+  // stdio. Returns empty stdout/stderr since output already went to the
+  // user's terminal.
+  // Codex r26 P2: parseFlags treats the bare `-f` short flag as the
+  // subcommand. Match it there too so `gd tail -f` streams instead of
+  // hanging in execFileSync.
+  const isFollowTail =
+    command === 'tail' &&
+    (subcommand === '-f' || subcommand === '--follow' ||
+     extraArgs.includes('-f') || extraArgs.includes('--follow') ||
+     passthrough.includes('-f') || passthrough.includes('--follow'));
+  const isWatch = command === 'watch';
+  if (isFollowTail || isWatch) {
+    const { spawnSync } = require('child_process') as typeof import('child_process');
+    const result = spawnSync('node', [grdTools, ...args], {
+      cwd,
+      stdio: 'inherit',
+      env: { ...process.env },
+    });
+    return { exitCode: result.status ?? 0, stdout: '', stderr: '' };
+  }
+
+  try {
+    const stdout = execFileSync('node', [grdTools, ...args], {
+      cwd,
+      encoding: 'utf-8',
+      maxBuffer: 50 * 1024 * 1024,
+      env: { ...process.env },
+    });
+    return { exitCode: 0, stdout, stderr: '' };
+  } catch (err: unknown) {
+    const error = err as { status?: number; stdout?: string; stderr?: string };
+    return {
+      exitCode: error.status || 1,
+      stdout: error.stdout || '',
+      stderr: error.stderr || '',
+    };
+  }
+}
+
+module.exports = { buildToolArgs, runToolCommand };

package/lib/commands/_dashboard-parsers.ts

@@ -0,0 +1,275 @@
+'use strict';
+
+/** GRD Commands/Dashboard -- Internal parse helpers for dashboard data extraction */
+
+
+const fs = require('fs');
+const path = require('path');
+
+const {
+  normalizePhaseName,
+}: {
+  normalizePhaseName: (phase: string) => string;
+} = require('../utils');
+
+// ─── Domain Types (shared with dashboard.ts) ─────────────────────────────────
+
+interface MilestoneEntry {
+  name: string;
+  number: number | null;
+  version: string | null;
+  goal: string | null;
+  start: string | null;
+  target: string | null;
+  status?: string;
+  shipped_date?: string;
+  phase_range?: string | null;
+  phase_count?: number;
+  progress_percent: number;
+  phases: PhaseData[];
+}
+
+interface PhaseData {
+  number: string;
+  name: string;
+  type: string | null;
+  duration: string | null;
+  plans: number;
+  summaries: number;
+  status: string;
+  active: boolean;
+  plan_files: string[];
+  summary_files: string[];
+}
+
+interface StateSummary {
+  activeBlockers: number;
+  blockerItems: string[];
+  pendingDeferred: number;
+  totalDecisions: number;
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeShippedMilestone(
+  name: string,
+  version: string,
+  shippedDate: string,
+  phaseRange: string | null,
+  phaseCount: number
+): MilestoneEntry {
+  return {
+    name,
+    number: null,
+    version,
+    goal: null,
+    start: null,
+    target: null,
+    status: 'shipped',
+    shipped_date: shippedDate,
+    phase_range: phaseRange,
+    phase_count: phaseCount,
+    progress_percent: 100,
+    phases: [],
+  };
+}
+
+function parseDashboardShippedMilestones(roadmapContent: string): MilestoneEntry[] {
+  const shippedMilestones: MilestoneEntry[] = [];
+  const milestonesSection = roadmapContent.match(/^##\s+Milestones\s*\n([\s\S]*?)(?=\n##\s|\n$)/m);
+  if (!milestonesSection) return shippedMilestones;
+
+  const shippedWithPhasesRegex =
+    /^-\s+(v[\d.]+)\s+(.+?)\s*-\s*Phases\s+(\d+)-(\d+)\s*\(shipped\s+(\d{4}-\d{2}-\d{2})\)/gm;
+  const shippedNoPhasesRegex = /^-\s+(v[\d.]+)\s+(.+?)\s*\(shipped\s+(\d{4}-\d{2}-\d{2})\)/gm;
+  const seen = new Set<string>();
+  let sMatch: RegExpExecArray | null;
+  while ((sMatch = shippedWithPhasesRegex.exec(milestonesSection[1])) !== null) {
+    const startPhase = parseInt(sMatch[3]);
+    const endPhase = parseInt(sMatch[4]);
+    seen.add(sMatch[1]);
+    shippedMilestones.push(
+      makeShippedMilestone(
+        sMatch[2].trim(),
+        sMatch[1],
+        sMatch[5],
+        `${startPhase}-${endPhase}`,
+        endPhase - startPhase + 1
+      )
+    );
+  }
+  while ((sMatch = shippedNoPhasesRegex.exec(milestonesSection[1])) !== null) {
+    if (seen.has(sMatch[1])) continue;
+    shippedMilestones.push(makeShippedMilestone(sMatch[2].trim(), sMatch[1], sMatch[3], null, 0));
+  }
+  return shippedMilestones;
+}
+
+function parseDashboardActiveMilestones(roadmapContent: string): {
+  activeMilestones: MilestoneEntry[];
+  milestonePositions: { index: number }[];
+} {
+  const milestoneRegex = /^##\s+(Milestone\s+\d+[^:\n]*:\s*([^\n]+)|.*v(\d+\.\d+)[^\n]*)/gim;
+  const activeMilestones: MilestoneEntry[] = [];
+  const milestonePositions: { index: number }[] = [];
+  let mMatch: RegExpExecArray | null;
+
+  while ((mMatch = milestoneRegex.exec(roadmapContent)) !== null) {
+    const heading = mMatch[0].replace(/^##\s+/, '').trim();
+    if (/^(Milestones|Phases|Deferred\s+Validations)$/i.test(heading)) continue;
+    const nameMatch = heading.match(/Milestone\s+\d+\s*:\s*(.+)/i);
+    const mFormatNameMatch = !nameMatch ? heading.match(/M\d+[^:]*:\s*(.+)/i) : null;
+    const versionMatch = heading.match(/v(\d+\.\d+)/);
+    const numMatch = heading.match(/(?:Milestone\s+|M)(\d+)/i);
+    const name = nameMatch
+      ? nameMatch[1].trim()
+      : mFormatNameMatch
+        ? mFormatNameMatch[1].trim()
+        : heading;
+    const version = versionMatch ? 'v' + versionMatch[1] : null;
+    const number = numMatch ? parseInt(numMatch[1]) : null;
+
+    const afterHeading = roadmapContent.slice(mMatch.index, mMatch.index + 500);
+    const startMatch = afterHeading.match(/\*\*Start:\*\*\s*(\d{4}-\d{2}-\d{2})/);
+    const targetMatch = afterHeading.match(/\*\*Target:\*\*\s*(\d{4}-\d{2}-\d{2})/);
+    const goalMatch = afterHeading.match(/\*\*Goal:\*\*\s*(.+)/);
+
+    activeMilestones.push({
+      name,
+      number,
+      version,
+      goal: goalMatch ? goalMatch[1].trim() : null,
+      start: startMatch ? startMatch[1] : null,
+      target: targetMatch ? targetMatch[1] : null,
+      phases: [],
+      progress_percent: 0,
+    });
+    milestonePositions.push({ index: mMatch.index });
+  }
+  return { activeMilestones, milestonePositions };
+}
+
+function parseDashboardPhases(
+  roadmapContent: string,
+  phasesDir: string,
+  milestonePositions: { index: number }[],
+  activePhaseNum: string | null,
+  activeMilestones: MilestoneEntry[]
+): PhaseData[] {
+  const phaseRegex = /#{2,}\s*Phase\s+(\d+(?:\.\d+)?)\s*:\s*([^\n]+)/gi;
+  let pMatch: RegExpExecArray | null;
+  const allPhases: PhaseData[] = [];
+
+  while ((pMatch = phaseRegex.exec(roadmapContent)) !== null) {
+    const phaseNum = pMatch[1];
+    const phaseName = pMatch[2].replace(/\(INSERTED\)/i, '').trim();
+    const sectionStart = pMatch.index;
+    const restContent = roadmapContent.slice(sectionStart + pMatch[0].length);
+    const nextHeading = restContent.match(/\n###?\s/);
+    const sectionText = nextHeading
+      ? roadmapContent.slice(
+          sectionStart,
+          sectionStart + pMatch[0].length + (nextHeading.index ?? 0)
+        )
+      : roadmapContent.slice(sectionStart);
+    const durationMatch = sectionText.match(/\*\*Duration:\*\*\s*(\d+)d/);
+    const duration = durationMatch ? durationMatch[1] + 'd' : null;
+    const typeMatch = sectionText.match(/\*\*Type:\*\*\s*(\w+)/);
+    const type = typeMatch ? typeMatch[1] : null;
+
+    let activeMsIdx = 0;
+    for (let i = 0; i < milestonePositions.length; i++) {
+      if (pMatch.index > milestonePositions[i].index) activeMsIdx = i;
+    }
+
+    const normalized = normalizePhaseName(phaseNum);
+    let plans = 0,
+      summaries = 0;
+    let planFiles: string[] = [];
+    let summaryFiles: string[] = [];
+    try {
+      const entries: { isDirectory: () => boolean; name: string }[] = fs.readdirSync(phasesDir, {
+        withFileTypes: true,
+      });
+      const dirs = entries
+        .filter((e: { isDirectory: () => boolean }) => e.isDirectory())
+        .map((e: { name: string }) => e.name);
+      const dirMatch = dirs.find((d: string) => d.startsWith(normalized + '-') || d === normalized);
+      if (dirMatch) {
+        const phaseFiles: string[] = fs.readdirSync(path.join(phasesDir, dirMatch));
+        planFiles = phaseFiles
+          .filter((f: string) => f.endsWith('-PLAN.md') || f === 'PLAN.md')
+          .sort();
+        plans = planFiles.length;
+        summaryFiles = phaseFiles.filter(
+          (f: string) => f.endsWith('-SUMMARY.md') || f === 'SUMMARY.md'
+        );
+        summaries = summaryFiles.length;
+      }
+    } catch {
+      /* no phases dir */
+    }
+
+    let status: string;
+    if (plans === 0) status = 'pending';
+    else if (summaries >= plans) status = 'complete';
+    else if (summaries > 0) status = 'in-progress';
+    else status = 'planned';
+
+    const phaseData: PhaseData = {
+      number: phaseNum,
+      name: phaseName,
+      type,
+      duration,
+      plans,
+      summaries,
+      status,
+      active: activePhaseNum === phaseNum,
+      plan_files: planFiles,
+      summary_files: summaryFiles,
+    };
+    allPhases.push(phaseData);
+    if (activeMilestones[activeMsIdx]) activeMilestones[activeMsIdx].phases.push(phaseData);
+  }
+  return allPhases;
+}
+
+function parseDashboardStateSummary(stateContent: string): StateSummary {
+  let activeBlockers = 0;
+  let blockerItems: string[] = [];
+  const blockersSection = stateContent.match(/##\s*Blockers\s*\n([\s\S]*?)(?=\n##|$)/i);
+  if (blockersSection) {
+    const items = blockersSection[1].match(/^-\s+(.+)$/gm) || [];
+    const filtered = items.filter((item: string) => {
+      const text = item.replace(/^-\s+/, '').trim();
+      return text.toLowerCase() !== 'none' && text.toLowerCase() !== 'none.';
+    });
+    activeBlockers = filtered.length;
+    blockerItems = filtered.map((item: string) => item.replace(/^-\s+/, '').trim());
+  }
+
+  let pendingDeferred = 0;
+  const deferredSection = stateContent.match(/##\s*Deferred Validations\s*\n([\s\S]*?)(?=\n##|$)/i);
+  if (deferredSection) {
+    const pendingMatches = deferredSection[1].match(/PENDING/gi);
+    pendingDeferred = pendingMatches ? pendingMatches.length : 0;
+  }
+
+  let totalDecisions = 0;
+  const decisionsSection = stateContent.match(/##\s*Key Decisions\s*\n([\s\S]*?)(?=\n##|$)/i);
+  if (decisionsSection) {
+    const tableRows = decisionsSection[1].match(/^\|[^|]/gm);
+    totalDecisions = tableRows ? Math.max(0, tableRows.length - 2) : 0;
+  }
+
+  return { activeBlockers, blockerItems, pendingDeferred, totalDecisions };
+}
+
+// ─── Exports ─────────────────────────────────────────────────────────────────
+
+module.exports = {
+  parseDashboardShippedMilestones,
+  parseDashboardActiveMilestones,
+  parseDashboardPhases,
+  parseDashboardStateSummary,
+};