vibepro 0.1.0-alpha.0

package/src/language.js

@@ -0,0 +1,48 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+import { getWorkspaceDir, initWorkspace } from './workspace.js';
+
+export const DEFAULT_OUTPUT_LANGUAGE = 'ja';
+export const SUPPORTED_OUTPUT_LANGUAGES = new Set(['ja', 'en']);
+
+export function normalizeOutputLanguage(value) {
+  return SUPPORTED_OUTPUT_LANGUAGES.has(value) ? value : DEFAULT_OUTPUT_LANGUAGE;
+}
+
+export function assertOutputLanguage(value) {
+  if (SUPPORTED_OUTPUT_LANGUAGES.has(value)) return value;
+  throw new Error(`Unsupported output language: ${value}. Supported languages: ja, en`);
+}
+
+export function resolveOutputLanguage(config, override = null) {
+  if (override) return assertOutputLanguage(override);
+  return normalizeOutputLanguage(config?.output?.language);
+}
+
+export async function resolveHumanOutputLanguage(repoRoot, options = {}) {
+  const override = typeof options === 'string' ? options : options.language;
+  if (override) return assertOutputLanguage(override);
+  await initWorkspace(repoRoot);
+  const configPath = path.join(getWorkspaceDir(repoRoot), 'config.json');
+  const config = JSON.parse(await readFile(configPath, 'utf8'));
+  return resolveOutputLanguage(config);
+}
+
+export function localizedText(language, values) {
+  const normalized = normalizeOutputLanguage(language);
+  return values[normalized] ?? values[DEFAULT_OUTPUT_LANGUAGE] ?? values.en ?? '';
+}
+
+export async function setOutputLanguage(repoRoot, language) {
+  const normalized = assertOutputLanguage(language);
+  await initWorkspace(repoRoot);
+  const configPath = path.join(getWorkspaceDir(repoRoot), 'config.json');
+  const config = JSON.parse(await readFile(configPath, 'utf8'));
+  config.output = {
+    ...(config.output ?? {}),
+    language: normalized
+  };
+  await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`);
+  return { language: normalized, config };
+}

package/src/lazy-pattern-detector.js

@@ -0,0 +1,182 @@
+const SCHEMA_VERSION = '0.1.0';
+const SNIPPET_MAX = 120;
+
+const TEST_PATH_PATTERNS = [
+  /(^|\/)tests?\//,
+  /(^|\/)__tests?__\//,
+  /\.(test|spec)\.[cm]?[jt]sx?$/,
+  /\.(test|spec)\.py$/,
+  /_test\.(go|rs)$/
+];
+
+const PATTERNS = [
+  {
+    id: 'merge_conflict_marker',
+    severity: 'critical',
+    applies_to: () => true,
+    message: 'Merge conflict markers present in committed text.',
+    fix_hint: 'Resolve the merge conflict and remove the <<<<<<<, =======, and >>>>>>> markers before committing.',
+    file_check(addedLines) {
+      let openMarker = null;
+      let separator = null;
+      let close = null;
+      for (const entry of addedLines) {
+        if (entry.content.startsWith('<<<<<<<')) openMarker = entry;
+        else if (entry.content.startsWith('=======') && openMarker && !separator) separator = entry;
+        else if (entry.content.startsWith('>>>>>>>') && openMarker && separator) close = entry;
+      }
+      if (openMarker && separator && close) {
+        return { line_number: openMarker.line_number, snippet: trimSnippet(openMarker.content) };
+      }
+      return null;
+    }
+  },
+  {
+    id: 'commit_marker_left_in',
+    severity: 'high',
+    applies_to: (filePath) => !isTestPath(filePath),
+    message: 'Self-addressed commit marker left in the change.',
+    fix_hint: 'Remove the marker; if the work is truly unfinished, split it into a follow-up PR or mark the entire PR as a draft.',
+    pattern: /\b(REMOVE BEFORE COMMIT|DO NOT COMMIT|DEBUG ONLY)\b/
+  },
+  {
+    id: 'debug_print_left_in',
+    severity: 'high',
+    applies_to: (filePath) => {
+      if (isTestPath(filePath)) return false;
+      return /\.(js|ts|jsx|tsx|mjs|cjs|py|rs)$/.test(filePath);
+    },
+    message: 'Debug print or logging statement left in non-test source.',
+    fix_hint: 'Remove the debug line, or replace it with a real logger call wired through the project\'s logging facility.',
+    match(line, filePath) {
+      if (/\bconsole\.(log|debug)\s*\(/.test(line)) return { snippet: trimSnippet(line), fix_hint: null };
+      if (/\bdebugger\s*;/.test(line)) return { snippet: trimSnippet(line), fix_hint: null };
+      if (filePath.endsWith('.py') && /(^|\s)print\s*\(/.test(line)) return { snippet: trimSnippet(line), fix_hint: null };
+      if (filePath.endsWith('.rs') && /\bdbg!\s*\(/.test(line)) return { snippet: trimSnippet(line), fix_hint: null };
+      return null;
+    }
+  },
+  {
+    id: 'silent_catch',
+    severity: 'high',
+    applies_to: (filePath) => !isTestPath(filePath),
+    message: 'Empty catch block silently swallows errors.',
+    fix_hint: 'Log the error, rethrow, or document explicitly with a comment why the failure is being ignored.',
+    match(line, filePath) {
+      if (/\}\s*catch\s*(?:\(\s*\w*\s*\))?\s*\{\s*\}/.test(line)) return { snippet: trimSnippet(line) };
+      if (filePath.endsWith('.py') && /except[^:]*:\s*pass\b/.test(line)) return { snippet: trimSnippet(line) };
+      return null;
+    }
+  },
+  {
+    id: 'todo_fixme_marker',
+    severity: 'medium',
+    applies_to: (filePath) => !/\.md$/i.test(filePath),
+    message: 'TODO/FIXME/XXX marker left in committed source.',
+    fix_hint: 'Either resolve the marker now or link it to a tracked issue and convert it into a concrete reference.',
+    pattern: /\b(TODO|FIXME|XXX)\b/
+  },
+  {
+    id: 'eslint_disable_without_reason',
+    severity: 'medium',
+    applies_to: (filePath) => /\.(js|ts|jsx|tsx|mjs|cjs)$/.test(filePath),
+    message: 'eslint-disable directive used without a trailing justification.',
+    fix_hint: 'Add a short `-- because <reason>` clause so a future reviewer knows why the rule is suppressed.',
+    match(line) {
+      const m = line.match(/eslint-disable(?:-next-line|-line)?(?:\s+([^*\n]*))?/);
+      if (!m) return null;
+      const tail = (m[1] ?? '').trim();
+      if (!tail) return { snippet: trimSnippet(line) };
+      const afterRule = tail.replace(/^[\w@/-]+(?:,\s*[\w@/-]+)*/, '').trim();
+      if (!afterRule || /^[*/]+$/.test(afterRule)) return { snippet: trimSnippet(line) };
+      return null;
+    }
+  },
+  {
+    id: 'placeholder_text',
+    severity: 'medium',
+    applies_to: () => true,
+    message: 'Generic placeholder text left in the change.',
+    fix_hint: 'Replace with a real value, or remove the snippet entirely if it was only filler.',
+    pattern: /\b(lorem ipsum|Acme Corp|Acme Corporation|John Doe|Jane Doe|foo@bar\.com|user@example\.com|example\.com)\b/i
+  },
+  {
+    id: 'em_dash_in_prose',
+    severity: 'low',
+    applies_to: (filePath) => /\.md$/i.test(filePath),
+    message: 'Em dash (—) detected in Markdown prose — a common AI tell.',
+    fix_hint: 'Prefer a comma, period, or " - " hyphen-space depending on intent; em dashes are rare in human-edited prose.',
+    pattern: /—/
+  }
+];
+
+export function detectLazyPatterns({ files } = {}) {
+  const findings = [];
+  if (!Array.isArray(files)) {
+    return { schema_version: SCHEMA_VERSION, findings };
+  }
+  for (const file of files) {
+    if (!file || typeof file.path !== 'string') continue;
+    const addedLines = Array.isArray(file.added_lines) ? file.added_lines : [];
+    for (const pattern of PATTERNS) {
+      try {
+        if (!pattern.applies_to(file.path)) continue;
+        if (typeof pattern.file_check === 'function') {
+          const hit = pattern.file_check(addedLines);
+          if (hit) {
+            findings.push({
+              pattern_id: pattern.id,
+              severity: pattern.severity,
+              file: file.path,
+              line_number: hit.line_number,
+              snippet: hit.snippet,
+              message: pattern.message,
+              fix_hint: hit.fix_hint ?? pattern.fix_hint
+            });
+          }
+          continue;
+        }
+        for (const entry of addedLines) {
+          if (!entry || typeof entry.content !== 'string') continue;
+          let hit = null;
+          if (typeof pattern.match === 'function') {
+            hit = pattern.match(entry.content, file.path);
+          } else if (pattern.pattern instanceof RegExp && pattern.pattern.test(entry.content)) {
+            hit = { snippet: trimSnippet(entry.content) };
+          }
+          if (hit) {
+            findings.push({
+              pattern_id: pattern.id,
+              severity: pattern.severity,
+              file: file.path,
+              line_number: entry.line_number,
+              snippet: hit.snippet,
+              message: pattern.message,
+              fix_hint: hit.fix_hint ?? pattern.fix_hint
+            });
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  return { schema_version: SCHEMA_VERSION, findings };
+}
+
+export function listLazyPatternCatalog() {
+  return PATTERNS.map((pattern) => ({
+    id: pattern.id,
+    severity: pattern.severity,
+    message: pattern.message
+  }));
+}
+
+function isTestPath(filePath) {
+  return TEST_PATH_PATTERNS.some((re) => re.test(filePath));
+}
+
+function trimSnippet(text) {
+  const trimmed = String(text).trim();
+  return trimmed.length > SNIPPET_MAX ? `${trimmed.slice(0, SNIPPET_MAX - 1)}…` : trimmed;
+}

package/src/local-dev-scanner.js

@@ -0,0 +1,135 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+
+export async function scanLocalDev(repoRoot) {
+  const packageJson = await readPackageJson(repoRoot);
+  const scripts = packageJson?.scripts ?? {};
+  const heavyDevScripts = Object.entries(scripts)
+    .filter(([name]) => name === 'dev' || name.startsWith('dev:'))
+    .map(([name, command]) => analyzeDevScript(name, command, scripts))
+    .filter(Boolean);
+
+  return {
+    package_json_found: Boolean(packageJson),
+    scanned_scripts: Object.keys(scripts).filter((name) => name === 'dev' || name.startsWith('dev:')).length,
+    heavy_dev_scripts: heavyDevScripts,
+    runtime_probe_plan: buildRuntimeProbePlan(scripts, heavyDevScripts),
+    risk_summary: {
+      heavy_dev_scripts: summarizeGateEffects(heavyDevScripts)
+    }
+  };
+}
+
+async function readPackageJson(repoRoot) {
+  try {
+    return JSON.parse(await readFile(path.join(repoRoot, 'package.json'), 'utf8'));
+  } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+function analyzeDevScript(name, command, scripts) {
+  if (typeof command !== 'string' || command.trim() === '') return null;
+  const concurrentlyCommands = extractConcurrentlyCommands(command);
+  const workerScriptRefs = countWorkerScriptRefs(command, scripts);
+  const hasNextDev = /\bnext\s+dev\b/.test(command);
+  const preDevCommands = countPreDevCommands(command);
+  const processCount = concurrentlyCommands.length > 0
+    ? concurrentlyCommands.length
+    : 1 + workerScriptRefs;
+
+  if (processCount < 4 && workerScriptRefs < 3 && preDevCommands < 2) return null;
+
+  return {
+    file: 'package.json',
+    script_name: name,
+    command,
+    kind: 'heavy_local_dev_script',
+    process_count: processCount,
+    worker_script_refs: workerScriptRefs,
+    pre_dev_command_count: preDevCommands,
+    has_next_dev: hasNextDev,
+    has_concurrently: concurrentlyCommands.length > 0,
+    gate_effect: 'review',
+    confidence: concurrentlyCommands.length > 0 && workerScriptRefs > 0 ? 'high' : 'medium',
+    recommendation: 'UI確認用のweb-only dev scriptとworker起動scriptを分離し、必要なworkerだけを明示起動できるようにする。'
+  };
+}
+
+function extractConcurrentlyCommands(command) {
+  if (!/\bconcurrently\b/.test(command)) return [];
+  return [...command.matchAll(/"([^"]+)"|'([^']+)'/g)]
+    .map((match) => match[1] ?? match[2])
+    .filter(Boolean);
+}
+
+function countWorkerScriptRefs(command, scripts) {
+  const directRefs = (command.match(/\bnpm:worker[\w:-]*/g) ?? []).length;
+  const npmRunRefs = [...command.matchAll(/\bnpm\s+run\s+([A-Za-z0-9:_-]+)/g)]
+    .map((match) => match[1])
+    .filter((scriptName) => scriptName.includes('worker') || /worker/i.test(scripts[scriptName] ?? ''))
+    .length;
+  return directRefs + npmRunRefs;
+}
+
+function countPreDevCommands(command) {
+  const nextDevIndex = command.search(/\bnext\s+dev\b/);
+  if (nextDevIndex === -1) return 0;
+  const beforeNextDev = command.slice(0, nextDevIndex);
+  return (beforeNextDev.match(/&&|\|\|/g) ?? []).length;
+}
+
+function buildRuntimeProbePlan(scripts, heavyDevScripts) {
+  const webScript = resolveWebDevScript(scripts);
+  const fullScript = resolveFullDevScript(scripts, heavyDevScripts);
+  const commands = [
+    webScript ? {
+      id: 'web-dev-startup',
+      command: `npm run ${webScript}`,
+      metrics: ['startup_seconds', 'next_ready_log_time', 'process_rss_mb', 'process_cpu_percent'],
+      purpose: 'UI確認だけに必要なNext.js dev serverの起動時間と常駐メモリを測る。'
+    } : null,
+    fullScript ? {
+      id: 'full-local-startup',
+      command: `npm run ${fullScript}`,
+      metrics: ['startup_seconds', 'process_count', 'total_rss_mb', 'worker_rss_mb'],
+      purpose: 'worker込みのフルローカル起動が必要な時の上限コストを測る。'
+    } : null,
+    {
+      id: 'api-latency-projects',
+      command: 'curl -w "time_total=%{time_total}\\n" -o /dev/null -s http://localhost:${PORT:-3000}/api/projects',
+      metrics: ['api_latency_ms', 'http_status'],
+      purpose: 'ローカル初期表示に近いAPI latencyを測る。認証が必要な場合はブラウザ計測に置き換える。'
+    }
+  ].filter(Boolean);
+
+  return {
+    status: commands.length > 0 ? 'available' : 'unavailable',
+    auto_run: false,
+    reason: '診断は対象リポジトリのserverやworkerを自動起動しない。計測はtask実行時の明示操作として残す。',
+    commands
+  };
+}
+
+function resolveWebDevScript(scripts) {
+  if (scripts['dev:web']) return 'dev:web';
+  if (scripts.dev && /\bnext\s+dev\b/.test(scripts.dev) && !/\bconcurrently\b/.test(scripts.dev)) return 'dev';
+  if (scripts['dev:turbo'] && /\bnext\s+dev\b/.test(scripts['dev:turbo']) && !/\bconcurrently\b/.test(scripts['dev:turbo'])) return 'dev:turbo';
+  return null;
+}
+
+function resolveFullDevScript(scripts, heavyDevScripts) {
+  if (scripts['local:full']) return 'local:full';
+  if (scripts['dev:full']) return 'dev:full';
+  if (scripts['workers:dev']) return 'workers:dev';
+  return heavyDevScripts[0]?.script_name ?? null;
+}
+
+function summarizeGateEffects(hits) {
+  return {
+    block: hits.filter((hit) => hit.gate_effect === 'block').length,
+    review: hits.filter((hit) => hit.gate_effect === 'review').length,
+    info: hits.filter((hit) => hit.gate_effect === 'info').length
+  };
+}

package/src/managed-worktree-gate.js

@@ -0,0 +1,187 @@
+import { execFile } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+
+import { readDecisionRecordsIfExists } from './decision-records.js';
+import { resolveManagedWorktreeMode } from './managed-worktree.js';
+import { getWorkspaceDir } from './workspace.js';
+
+const execFileAsync = promisify(execFile);
+
+export async function buildManagedWorktreeGate(repoRoot, options = {}) {
+  const root = path.resolve(repoRoot);
+  const storyId = options.storyId;
+  const state = storyId ? await readBoundExecutionState(root, storyId) : null;
+  let managedWorktree = state?.managed_worktree ?? null;
+  if (managedWorktree?.path) {
+    managedWorktree = {
+      ...managedWorktree,
+      current_head_sha: await gitOptional(managedWorktree.path, ['rev-parse', 'HEAD']) ?? managedWorktree.current_head_sha ?? null
+    };
+  }
+  const mode = await resolveManagedWorktreeMode(managedWorktree?.source_repo ?? root);
+  const expectedPath = managedWorktree?.path ? path.resolve(managedWorktree.path) : null;
+  const currentPath = root;
+  const insideManagedWorktree = expectedPath ? isSameOrInside(currentPath, expectedPath) : false;
+  const decisionRecords = options.decisionRecords
+    ?? (storyId ? await readDecisionRecordsIfExists(root, storyId) : null);
+  const bypass = findAcceptedManagedWorktreeBypass(decisionRecords);
+  const missingReason = expectedPath
+    ? `current repo ${formatPath(currentPath)} is outside VibePro managed worktree ${formatPath(expectedPath)}`
+    : 'VibePro managed worktree execution state is missing';
+
+  if (mode === 'disabled') {
+    return {
+      id: 'gate:managed_worktree',
+      type: 'managed_worktree_gate',
+      label: 'Managed Worktree Gate',
+      status: 'not_applicable',
+      required: false,
+      mode,
+      current_repo: currentPath,
+      managed_worktree_path: expectedPath,
+      reason: 'managed worktree mode is disabled'
+    };
+  }
+
+  if (bypass) {
+    return {
+      id: 'gate:managed_worktree',
+      type: 'managed_worktree_gate',
+      label: 'Managed Worktree Gate',
+      status: 'bypassed',
+      required: mode === 'required',
+      mode,
+      current_repo: currentPath,
+      managed_worktree_path: expectedPath,
+      branch: managedWorktree?.branch ?? null,
+      current_head_sha: managedWorktree?.current_head_sha ?? null,
+      managed_worktree: managedWorktree,
+      decision_id: bypass.decision_id,
+      reason: `accepted bypass decision recorded: ${bypass.reason ?? bypass.summary ?? bypass.decision_id}`
+    };
+  }
+
+  if (insideManagedWorktree) {
+    return {
+      id: 'gate:managed_worktree',
+      type: 'managed_worktree_gate',
+      label: 'Managed Worktree Gate',
+      status: 'passed',
+      required: mode === 'required',
+      mode,
+      current_repo: currentPath,
+      managed_worktree_path: expectedPath,
+      branch: managedWorktree?.branch ?? null,
+      current_head_sha: managedWorktree?.current_head_sha ?? null,
+      managed_worktree: managedWorktree,
+      reason: 'command is running inside the VibePro managed worktree'
+    };
+  }
+
+  return {
+    id: 'gate:managed_worktree',
+    type: 'managed_worktree_gate',
+    label: 'Managed Worktree Gate',
+    status: mode === 'required' ? 'block' : 'needs_review',
+    required: mode === 'required',
+    mode,
+    current_repo: currentPath,
+    managed_worktree_path: expectedPath,
+    branch: managedWorktree?.branch ?? null,
+    current_head_sha: managedWorktree?.current_head_sha ?? null,
+    managed_worktree: managedWorktree,
+    reason: missingReason
+  };
+}
+
+export async function assertManagedWorktreeCommandAllowed(repoRoot, options = {}) {
+  const gate = await buildManagedWorktreeGate(repoRoot, options);
+  if (gate.mode !== 'required' || ['passed', 'bypassed'].includes(gate.status)) {
+    return gate;
+  }
+  const commandName = options.commandName ?? 'command';
+  throw new Error(
+    `${commandName} is blocked by gate:managed_worktree. ${gate.reason}. ` +
+    'Run the command from `vibepro execute start` managed_worktree.path or record an accepted waiver with ' +
+    '`vibepro decision record --type waiver --source gate:managed_worktree --reason <reason>`.'
+  );
+}
+
+export function formatManagedWorktreePrStatus(gate) {
+  if (!gate) return 'unknown';
+  if (gate.status === 'passed') return 'passed';
+  if (gate.status === 'bypassed') return 'bypassed';
+  if (gate.status === 'not_applicable') return 'disabled';
+  if (gate.status === 'block') return 'needs_review';
+  return gate.status ?? 'unknown';
+}
+
+async function readExecutionStateIfExists(repoRoot, storyId) {
+  try {
+    return JSON.parse(await readFile(path.join(getWorkspaceDir(repoRoot), 'executions', storyId, 'state.json'), 'utf8'));
+  } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+async function readBoundExecutionState(repoRoot, storyId) {
+  const localState = await readExecutionStateIfExists(repoRoot, storyId);
+  if (localState?.managed_worktree) return localState;
+
+  const worktrees = await listGitWorktrees(repoRoot);
+  for (const worktreePath of worktrees) {
+    if (path.resolve(worktreePath) === path.resolve(repoRoot)) continue;
+    const state = await readExecutionStateIfExists(worktreePath, storyId);
+    const managedPath = state?.managed_worktree?.path ? path.resolve(state.managed_worktree.path) : null;
+    if (managedPath && isSameOrInside(path.resolve(repoRoot), managedPath)) return state;
+  }
+  return null;
+}
+
+async function listGitWorktrees(repoRoot) {
+  try {
+    const { stdout } = await execFileAsync('git', ['worktree', 'list', '--porcelain'], {
+      cwd: repoRoot,
+      encoding: 'utf8'
+    });
+    return stdout
+      .split('\n')
+      .map((line) => line.startsWith('worktree ') ? line.slice('worktree '.length) : null)
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+async function gitOptional(repoRoot, args) {
+  try {
+    const { stdout } = await execFileAsync('git', args, {
+      cwd: repoRoot,
+      encoding: 'utf8'
+    });
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+function findAcceptedManagedWorktreeBypass(decisionRecords) {
+  const decisions = Array.isArray(decisionRecords?.decisions) ? decisionRecords.decisions : [];
+  return decisions.find((decision) => decision
+    && decision.type === 'waiver'
+    && decision.status === 'accepted'
+    && decision.source === 'gate:managed_worktree') ?? null;
+}
+
+function isSameOrInside(candidate, parent) {
+  const relative = path.relative(parent, candidate);
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+function formatPath(filePath) {
+  if (!filePath) return '-';
+  return filePath;
+}