@jokerized/getresearchdone 0.4.1

package/lib/commands/check-plans.ts

@@ -0,0 +1,233 @@
+'use strict';
+
+/** GRD Commands/CheckPlans -- Validate plan files for stale file paths */
+
+const fs = require('fs') as typeof import('fs');
+const path = require('path') as typeof import('path');
+
+const {
+  output,
+  error,
+  findPhaseInternal,
+}: {
+  output: (result: unknown, raw: boolean, rawValue?: unknown) => never;
+  error: (msg: string) => never;
+  findPhaseInternal: (cwd: string, phase: string) => import('../types').PhaseInfo | null;
+} = require('../utils');
+
+const {
+  phasesDir: getPhasesDirPath,
+}: {
+  phasesDir: (cwd: string, milestone?: string | null) => string;
+} = require('../paths');
+
+interface PlanFileIssue {
+  path: string;
+  status: 'missing' | 'found';
+}
+
+interface PlanCheckResult {
+  plan_file: string;
+  plan_path: string;
+  missing_count: number;
+  issues: PlanFileIssue[];
+}
+
+interface CheckPlansResult {
+  phase?: string;
+  plans_checked: number;
+  total_missing: number;
+  plan_results: PlanCheckResult[];
+}
+
+function _extractFilePathsFromFrontmatter(fm: string): string[] {
+  // Codex r14 P2: standard GRD plans declare paths via `files_modified:`
+  // and per-artifact `path:` entries under `must_haves.artifacts`, not
+  // a `## Files` section. Parse those before falling back to the
+  // section scanner so check-plans reports the right missing files.
+  const paths: string[] = [];
+
+  // Codex r15 P2: prior regex matched only the first list item of a
+  // multi-line YAML block. Walk the frontmatter line-by-line so every
+  // entry under `files_modified:` is captured.
+  const lines = fm.split('\n');
+  let inFilesModified = false;
+  for (const line of lines) {
+    // Inline-array form: `files_modified: [a.ts, b.ts]`
+    const inlineMatch = line.match(/^files_modified\s*:\s*\[(.+)\]/);
+    if (inlineMatch) {
+      for (const item of inlineMatch[1].split(',')) {
+        const p = item.trim().replace(/^["']|["']$/g, '');
+        if (p && p.includes('.') && !p.startsWith('http')) paths.push(p);
+      }
+      continue;
+    }
+    if (/^files_modified\s*:\s*$/.test(line)) {
+      inFilesModified = true;
+      continue;
+    }
+    if (inFilesModified) {
+      const item = line.match(/^\s+-\s+["']?([^"'\n]+?)["']?\s*$/);
+      if (item) {
+        const p = item[1].trim();
+        if (p && p.includes('.') && !p.startsWith('http')) paths.push(p);
+        continue;
+      }
+      // Any non-indented line ends the block
+      if (/^\S/.test(line) || line.trim() === '') inFilesModified = false;
+    }
+  }
+
+  for (const m of fm.matchAll(/^\s+path\s*:\s*["']?([^"'\n]+?)["']?\s*$/gm)) {
+    const p = m[1].trim();
+    if (p && p.includes('.') && !p.startsWith('http')) paths.push(p);
+  }
+  return paths;
+}
+
+function _extractFilePaths(content: string): string[] {
+  const paths: string[] = [];
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (fmMatch) paths.push(..._extractFilePathsFromFrontmatter(fmMatch[1]));
+
+  const filesSectionMatch = content.search(/^##\s*Files?\b/im);
+  if (filesSectionMatch === -1) return paths;
+
+  const afterSection = content.slice(filesSectionMatch);
+  const newlineIdx = afterSection.indexOf('\n');
+  const rest = newlineIdx === -1 ? afterSection : afterSection.slice(newlineIdx + 1);
+  const nextSectionMatch = rest.search(/^##\s+/m);
+  const section = nextSectionMatch === -1 ? rest : rest.slice(0, nextSectionMatch);
+
+  const lineRe = /^[-*]\s+\*{0,2}([^\s*`(]+\.[a-zA-Z0-9]+)\*{0,2}/gm;
+  let m;
+  while ((m = lineRe.exec(section)) !== null) {
+    const p = m[1].trim();
+    if (p && !p.startsWith('http') && p.includes('.')) {
+      paths.push(p);
+    }
+  }
+  return paths;
+}
+
+function _checkPlanFile(cwd: string, planFilePath: string): PlanCheckResult {
+  let content: string;
+  try {
+    content = fs.readFileSync(planFilePath, 'utf-8');
+  } catch {
+    return {
+      plan_file: path.basename(planFilePath),
+      plan_path: path.relative(cwd, planFilePath),
+      missing_count: 0,
+      issues: [],
+    };
+  }
+
+  const filePaths = _extractFilePaths(content);
+  const issues: PlanFileIssue[] = filePaths.map((p) => {
+    const abs = path.isAbsolute(p) ? p : path.join(cwd, p);
+    return { path: p, status: fs.existsSync(abs) ? 'found' : 'missing' };
+  });
+
+  return {
+    plan_file: path.basename(planFilePath),
+    plan_path: path.relative(cwd, planFilePath),
+    missing_count: issues.filter((i) => i.status === 'missing').length,
+    issues,
+  };
+}
+
+/**
+ * CLI command: Validate plan files for stale (non-existent) file path references.
+ */
+function cmdCheckPlans(
+  cwd: string,
+  options: { phase?: string | null; milestone?: string | null },
+  raw: boolean
+): void {
+  const phasesBase = getPhasesDirPath(cwd, options.milestone ?? null);
+
+  let planFiles: string[] = [];
+
+  if (options.phase) {
+    // Codex r13 P2: when --milestone is explicit, look up the phase
+    // inside that milestone's phases dir instead of letting
+    // findPhaseInternal default to the current milestone.
+    let phaseDir: string | null = null;
+    if (options.milestone) {
+      const padded = /^\d+$/.test(options.phase) ? options.phase.padStart(2, '0') : options.phase;
+      try {
+        const match = (fs.readdirSync(phasesBase) as string[]).find(
+          (d: string) =>
+            d === options.phase || d === padded ||
+            d.startsWith(`${options.phase}-`) || d.startsWith(`${padded}-`)
+        );
+        if (match) phaseDir = path.join(phasesBase, match);
+      } catch { /* fall through */ }
+      if (!phaseDir) {
+        error(`Phase ${options.phase} not found in milestone ${options.milestone}`);
+      }
+    } else {
+      const phaseInfo = findPhaseInternal(cwd, options.phase);
+      if (!phaseInfo || !phaseInfo.found) {
+        error(`Phase ${options.phase} not found`);
+      }
+      phaseDir = path.join(cwd, (phaseInfo as import('../types').PhaseInfo).directory);
+    }
+    try {
+      planFiles = (fs.readdirSync(phaseDir!) as string[])
+        .filter((f: string) => f.endsWith('-PLAN.md') || f === 'PLAN.md')
+        .map((f: string) => path.join(phaseDir!, f));
+    } catch {
+      error(`Cannot read phase directory: ${phaseDir}`);
+    }
+  } else {
+    try {
+      const phaseDirs = (
+        fs.readdirSync(phasesBase, { withFileTypes: true }) as import('fs').Dirent[]
+      )
+        .filter((e) => e.isDirectory())
+        .map((e) => path.join(phasesBase, e.name));
+      for (const pd of phaseDirs) {
+        try {
+          const files = (fs.readdirSync(pd) as string[])
+            .filter((f: string) => f.endsWith('-PLAN.md') || f === 'PLAN.md')
+            .map((f: string) => path.join(pd, f));
+          planFiles.push(...files);
+        } catch {
+          // skip unreadable phase dir
+        }
+      }
+    } catch {
+      // phasesBase doesn't exist
+    }
+  }
+
+  const planResults: PlanCheckResult[] = planFiles.map((f) => _checkPlanFile(cwd, f));
+  const totalMissing = planResults.reduce((s, r) => s + r.missing_count, 0);
+
+  const result: CheckPlansResult = {
+    ...(options.phase ? { phase: options.phase } : {}),
+    plans_checked: planFiles.length,
+    total_missing: totalMissing,
+    plan_results: planResults.filter((r) => r.missing_count > 0 || planFiles.length <= 5),
+  };
+
+  if (raw) {
+    const lines = [`Plan check: ${planFiles.length} plan(s), ${totalMissing} stale path(s)`];
+    for (const r of planResults) {
+      if (r.missing_count > 0) {
+        lines.push(`  ${r.plan_file}: ${r.missing_count} missing`);
+        for (const issue of r.issues.filter((i) => i.status === 'missing')) {
+          lines.push(`    x ${issue.path}`);
+        }
+      }
+    }
+    if (totalMissing === 0) lines.push('  All file references valid.');
+    output(result, raw, lines.join('\n'));
+  } else {
+    output(result, raw, `${planFiles.length} plans, ${totalMissing} missing paths`);
+  }
+}
+
+module.exports = { cmdCheckPlans };

package/lib/commands/config.ts

@@ -0,0 +1,287 @@
+'use strict';
+
+/** GRD Commands/Config -- Configuration management and path verification operations */
+
+
+const fs = require('fs');
+const path = require('path');
+
+const {
+  output,
+  error,
+}: {
+  output: (result: unknown, raw: boolean, rawValue?: unknown) => never;
+  error: (message: string) => never;
+} = require('../utils');
+const {
+  planningDir: getPlanningDir,
+}: {
+  planningDir: (cwd: string) => string;
+} = require('../paths');
+
+// ─── Domain Types ────────────────────────────────────────────────────────────
+
+/** Default config structure created by cmdConfigEnsureSection. */
+interface DefaultConfig {
+  model_profile: string;
+  commit_docs: boolean;
+  search_gitignored: boolean;
+  branching_strategy: string;
+  phase_branch_template: string;
+  milestone_branch_template: string;
+  workflow: {
+    research: boolean;
+    plan_check: boolean;
+    verifier: boolean;
+  };
+  parallelization: boolean;
+  autonomous_mode: boolean;
+  research_gates: {
+    verification_design: boolean;
+    method_selection: boolean;
+    baseline_review: boolean;
+  };
+  eval_config: {
+    default_metrics: string[];
+    baseline_tracking: boolean;
+  };
+  ceremony: {
+    default_level: string;
+    phase_overrides: Record<string, string>;
+  };
+  tracker: {
+    provider: string;
+    auto_sync: boolean;
+    github: {
+      project_board: string;
+      default_assignee: string;
+      default_labels: string[];
+      auto_issues: boolean;
+      pr_per_phase: boolean;
+    };
+    mcp_atlassian: {
+      base_url: string;
+      project_key: string;
+      auth_method: string;
+      epic_issue_type: string;
+      task_issue_type: string;
+    };
+  };
+}
+
+// ─── Path Verification ──────────────────────────────────────────────────────
+
+/**
+ * CLI command: Check if a path exists in the project and report its type.
+ * @param cwd - Project working directory
+ * @param targetPath - Path to check for existence
+ * @param raw - Output raw 'true'/'false' instead of JSON
+ * @param dryRun - If true, report what would be checked without side effects
+ */
+function cmdVerifyPathExists(
+  cwd: string,
+  targetPath: string,
+  raw: boolean,
+  dryRun?: boolean
+): void {
+  if (!targetPath) {
+    error('path required for verification. Usage: verify path-exists <path>');
+    return;
+  }
+
+  const fullPath: string = path.isAbsolute(targetPath) ? targetPath : path.join(cwd, targetPath);
+
+  if (dryRun) {
+    output(
+      { dry_run: true, path: targetPath, full_path: fullPath },
+      raw,
+      `dry-run: would check ${targetPath}`
+    );
+    return;
+  }
+
+  try {
+    const stats = fs.statSync(fullPath);
+    const type: string = stats.isDirectory() ? 'directory' : stats.isFile() ? 'file' : 'other';
+    const result = { exists: true, type };
+    output(result, raw, 'true');
+  } catch {
+    const result = { exists: false, type: null };
+    output(result, raw, 'false');
+  }
+}
+
+// ─── Config Ensure Section ──────────────────────────────────────────────────
+
+/**
+ * CLI command: Ensure config.json exists with required sections, creating defaults if missing.
+ * @param cwd - Project working directory
+ * @param raw - Output raw 'created'/'exists' instead of JSON
+ * @param dryRun - If true, preview changes without writing
+ */
+function cmdConfigEnsureSection(cwd: string, raw: boolean, dryRun?: boolean): void {
+  const planningDir: string = getPlanningDir(cwd);
+  const configPath: string = path.join(planningDir, 'config.json');
+
+  // Ensure .planning directory exists
+  try {
+    if (!fs.existsSync(planningDir)) {
+      fs.mkdirSync(planningDir, { recursive: true });
+    }
+  } catch (err: unknown) {
+    error('Failed to create .planning directory: ' + (err as Error).message);
+    return;
+  }
+
+  // Check if config already exists
+  if (fs.existsSync(configPath)) {
+    const result = { created: false, reason: 'already_exists' };
+    output(result, raw, 'exists');
+    return;
+  }
+
+  // Create default config
+  const defaults: DefaultConfig = {
+    model_profile: 'balanced',
+    commit_docs: true,
+    search_gitignored: false,
+    branching_strategy: 'none',
+    phase_branch_template: 'grd/{milestone}/{phase}-{slug}',
+    milestone_branch_template: 'grd/{milestone}-{slug}',
+    workflow: {
+      research: true,
+      plan_check: true,
+      verifier: true,
+    },
+    parallelization: true,
+    autonomous_mode: false,
+    research_gates: {
+      verification_design: true,
+      method_selection: true,
+      baseline_review: true,
+    },
+    eval_config: {
+      default_metrics: ['PSNR', 'SSIM', 'LPIPS'],
+      baseline_tracking: true,
+    },
+    ceremony: {
+      default_level: 'auto',
+      phase_overrides: {},
+    },
+    tracker: {
+      provider: 'none',
+      auto_sync: true,
+      github: {
+        project_board: '',
+        default_assignee: '',
+        default_labels: ['research', 'implementation', 'evaluation', 'integration'],
+        auto_issues: true,
+        pr_per_phase: false,
+      },
+      mcp_atlassian: {
+        base_url: '',
+        project_key: '',
+        auth_method: 'api_token',
+        epic_issue_type: 'Epic',
+        task_issue_type: 'Task',
+      },
+    },
+  };
+
+  if (dryRun) {
+    output(
+      { dry_run: true, would_create: path.relative(cwd, configPath) },
+      raw,
+      `dry-run: would create ${path.relative(cwd, configPath)}`
+    );
+    return;
+  }
+
+  try {
+    fs.writeFileSync(configPath, JSON.stringify(defaults, null, 2), 'utf-8');
+    const result = { created: true, path: path.relative(cwd, configPath) };
+    output(result, raw, 'created');
+  } catch (err: unknown) {
+    error('Failed to create config.json: ' + (err as Error).message);
+  }
+}
+
+// ─── Config Set ─────────────────────────────────────────────────────────────
+
+/**
+ * CLI command: Set a configuration value by dot-path key in config.json.
+ * @param cwd - Project working directory
+ * @param keyPath - Dot-notation key path (e.g., 'workflow.research')
+ * @param value - Value to set (auto-parsed to boolean/number if applicable)
+ * @param raw - Output raw 'key=value' instead of JSON
+ * @param dryRun - If true, preview changes without writing
+ */
+function cmdConfigSet(
+  cwd: string,
+  keyPath: string,
+  value: string,
+  raw: boolean,
+  dryRun?: boolean
+): void {
+  const configPath: string = path.join(getPlanningDir(cwd), 'config.json');
+
+  if (!keyPath) {
+    error('Usage: config-set <key.path> <value>');
+    return;
+  }
+
+  // Parse value (handle booleans and numbers)
+  let parsedValue: string | boolean | number = value;
+  if (value === 'true') parsedValue = true;
+  else if (value === 'false') parsedValue = false;
+  else if (!isNaN(Number(value)) && value !== '') parsedValue = Number(value);
+
+  // Load existing config or start with empty object
+  let config: Record<string, unknown> = {};
+  try {
+    if (fs.existsSync(configPath)) {
+      config = JSON.parse(fs.readFileSync(configPath, 'utf-8')) as Record<string, unknown>;
+    }
+  } catch (err: unknown) {
+    error('Failed to read config.json: ' + (err as Error).message);
+    return;
+  }
+
+  // Set nested value using dot notation (e.g., "workflow.research")
+  const keys: string[] = keyPath.split('.');
+  let current: Record<string, unknown> = config;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key: string = keys[i];
+    if (current[key] === undefined || typeof current[key] !== 'object') {
+      current[key] = {};
+    }
+    current = current[key] as Record<string, unknown>;
+  }
+  current[keys[keys.length - 1]] = parsedValue;
+
+  if (dryRun) {
+    output(
+      { dry_run: true, key: keyPath, value: parsedValue },
+      raw,
+      `dry-run: would set ${keyPath}=${parsedValue}`
+    );
+    return;
+  }
+
+  // Write back
+  try {
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+    const result = { updated: true, key: keyPath, value: parsedValue };
+    output(result, raw, `${keyPath}=${parsedValue}`);
+  } catch (err: unknown) {
+    error('Failed to write config.json: ' + (err as Error).message);
+  }
+}
+
+// ─── Exports ─────────────────────────────────────────────────────────────────
+
+module.exports = {
+  cmdConfigEnsureSection,
+  cmdConfigSet,
+  cmdVerifyPathExists,
+};