@unlaxer/dve-toolkit 4.1.0

package/parser/session-parser.ts

@@ -0,0 +1,213 @@
+// Session parser — graduated extraction from dge/sessions/*.md
+
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import type { Session, Gap, ParseResult } from "../graph/schema.js";
+
+const GAP_MARKER = /^.*→\s*Gap\s*発見[:：]\s*(.+)/;
+const GAP_TABLE_ROW = /\|\s*(\d+)\s*\|\s*(.+?)\s*\|\s*(.+?)\s*\|\s*\*{0,2}(Critical|High|Medium|Low)\*{0,2}\s*\|/;
+const GAP_TABLE_ROW_5COL = /\|\s*(\d+)\s*\|\s*(.+?)\s*\|\s*(.+?)\s*\|\s*(Critical|High|Medium|Low)\s*\|\s*(.+?)\s*\|/;
+const CHAR_LINE = /^\*{0,2}([^\*]+?)\*{0,2}[:：]/;
+const ICON_NAME = /^([\p{Emoji_Presentation}\p{Emoji}\uFE0F]+)\s*(.+)/u;
+
+interface SessionParseOutput {
+  session: ParseResult<Session>;
+  gaps: ParseResult<Gap>[];
+}
+
+function extractDateAndTheme(filename: string): { date: string; theme: string } | null {
+  const stem = path.basename(filename, ".md");
+  const match = stem.match(/^(\d{4}-\d{2}-\d{2})-(.+)$/);
+  if (match) return { date: match[1], theme: match[2] };
+  return null;
+}
+
+function extractFrontmatter(lines: string[]): Record<string, string> {
+  const fm: Record<string, string> = {};
+  for (const line of lines) {
+    const m = line.match(/^-\s+\*{0,2}(\w[\w\s]*?)\*{0,2}[:：]\s*(.+)/);
+    if (m) fm[m[1].trim().toLowerCase()] = m[2].trim();
+    if (line.startsWith("---") && Object.keys(fm).length > 0) break;
+    if (line.startsWith("## ") && Object.keys(fm).length > 0) break;
+  }
+  return fm;
+}
+
+export function parseSession(filePath: string): SessionParseOutput {
+  const content = readFileSync(filePath, "utf-8");
+  const lines = content.split("\n");
+  const warnings: string[] = [];
+
+  // Level 1: filename → date + id
+  const fileInfo = extractDateAndTheme(filePath);
+  const id = path.basename(filePath, ".md");
+  const date = fileInfo?.date ?? "";
+  const theme = fileInfo?.theme ?? "";
+
+  if (!fileInfo) {
+    warnings.push("Could not extract date/theme from filename");
+  }
+
+  // Frontmatter extraction
+  const fm = extractFrontmatter(lines);
+
+  // Characters from frontmatter
+  const charsRaw = fm["characters"] ?? "";
+  const characters = charsRaw
+    ? charsRaw.split(/[,、]/).map((c) => c.trim()).filter(Boolean)
+    : [];
+
+  const flow = fm["flow"]?.replace(/\s*\(.+\)/, "") ?? "quick";
+  const structure = fm["structure"] ?? "roundtable";
+  const sessionTheme = fm["theme"] ?? fm["テーマ"] ?? theme;
+
+  const session: ParseResult<Session> = {
+    node: {
+      id,
+      date,
+      theme: sessionTheme || theme,
+      flow,
+      structure,
+      characters,
+      file_path: filePath,
+      content,
+    },
+    confidence: fileInfo ? 0.9 : 0.5,
+    warnings: [...warnings],
+    source: { file: filePath },
+  };
+
+  // Level 2: Gap markers
+  const gaps: ParseResult<Gap>[] = [];
+  let gapIndex = 0;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const gapMatch = line.match(GAP_MARKER);
+    if (gapMatch) {
+      gapIndex++;
+      const gapId = `${id}#G-${String(gapIndex).padStart(3, "0")}`;
+      gaps.push({
+        node: {
+          id: gapId,
+          session_id: id,
+          summary: gapMatch[1].trim(),
+          category: "",
+          severity: "Unknown",
+          status: "Active",
+          line_ref: i + 1,
+          discovered_by: [],
+        },
+        confidence: 0.9,
+        warnings: [],
+        source: { file: filePath, line: i + 1 },
+      });
+    }
+  }
+
+  // Level 3: Gap table → category + severity (supports 4-col and 5-col tables)
+  const tableGaps: { index: number; summary: string; category: string; severity: string; status?: string }[] = [];
+  for (const line of lines) {
+    const match5 = line.match(GAP_TABLE_ROW_5COL);
+    if (match5) {
+      tableGaps.push({
+        index: parseInt(match5[1], 10),
+        summary: match5[2].trim(),
+        category: match5[3].trim(),
+        severity: match5[4],
+        status: match5[5].trim(),
+      });
+      continue;
+    }
+    const tableMatch = line.match(GAP_TABLE_ROW);
+    if (tableMatch) {
+      tableGaps.push({
+        index: parseInt(tableMatch[1], 10),
+        summary: tableMatch[2].trim(),
+        category: tableMatch[3].trim(),
+        severity: tableMatch[4],
+      });
+    }
+  }
+
+  // Collect all inline Gap markers with line numbers for cross-matching
+  const markerLines: { line: number; text: string }[] = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (GAP_MARKER.test(lines[i])) {
+      markerLines.push({ line: i + 1, text: lines[i] });
+    }
+  }
+
+  // If no gap markers found but table exists, create gaps from table
+  // Try to match table gaps to inline markers by keyword similarity
+  if (gaps.length === 0 && tableGaps.length > 0) {
+    for (const tg of tableGaps) {
+      const gapId = `${id}#G-${String(tg.index).padStart(3, "0")}`;
+      const status = tg.status?.includes("Resolved") ? "Archived" as const
+        : tg.status?.includes("Active") ? "Active" as const
+        : "Active" as const;
+
+      // Try to find matching inline marker by keyword overlap
+      let bestLine = 0;
+      let bestScore = 0;
+      const keywords = tg.summary.split(/[\s、。,./]+/).filter(w => w.length >= 2);
+      for (const marker of markerLines) {
+        let score = 0;
+        for (const kw of keywords) {
+          if (marker.text.includes(kw)) score++;
+        }
+        if (score > bestScore) {
+          bestScore = score;
+          bestLine = marker.line;
+        }
+      }
+
+      gaps.push({
+        node: {
+          id: gapId,
+          session_id: id,
+          summary: tg.summary,
+          category: tg.category,
+          severity: tg.severity as Gap["severity"],
+          status,
+          line_ref: bestLine, // 0 if no match found
+          discovered_by: [],
+        },
+        confidence: bestLine > 0 ? 0.85 : 0.8,
+        warnings: bestLine > 0 ? [] : ["Gap extracted from table (no inline marker found)"],
+        source: { file: filePath, line: bestLine || undefined },
+      });
+    }
+  } else {
+    // Match table rows to gaps by index
+    for (const tg of tableGaps) {
+      const gap = gaps[tg.index - 1];
+      if (gap?.node) {
+        if (tg.category) gap.node.category = tg.category;
+        if (tg.severity) {
+          gap.node.severity = tg.severity as Gap["severity"];
+          gap.confidence = 0.95;
+        }
+        if (tg.status?.includes("Resolved")) gap.node.status = "Archived";
+        if (tg.summary.length > (gap.node.summary?.length ?? 0)) {
+          gap.node.summary = tg.summary;
+        }
+      }
+    }
+
+    // Mark gaps without severity
+    for (const gap of gaps) {
+      if (gap.node.severity === "Unknown") {
+        gap.warnings.push("severity not found (no gap table or pre-v3 format)");
+        gap.confidence = Math.min(gap.confidence, 0.7);
+      }
+    }
+  }
+
+  if (gaps.length === 0) {
+    session.warnings.push("No gap markers found");
+    session.confidence = Math.min(session.confidence, 0.6);
+  }
+
+  return { session, gaps };
+}

package/parser/spec-parser.ts

@@ -0,0 +1,65 @@
+// Spec parser — extract specs from dge/specs/*.md
+
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import type { Spec, ParseResult } from "../graph/schema.js";
+
+const FIELD_RE = /^-\s+\*{0,2}(\w[\w\s/]*?)\*{0,2}[:：]\s*(.+)/;
+const DD_REF_RE = /DD-\d+/g;
+const SESSION_LINK_RE = /\[([^\]]+)\]\(\.\.\/sessions\/([^)]+)\)/g;
+
+export function parseSpec(filePath: string): ParseResult<Spec> {
+  const content = readFileSync(filePath, "utf-8");
+  const lines = content.split("\n");
+  const warnings: string[] = [];
+  const stem = path.basename(filePath, ".md");
+
+  // Title from H1
+  const h1 = lines.find((l) => l.startsWith("# "));
+  const rawTitle = h1?.replace(/^#\s+/, "") ?? stem;
+
+  // Extract type from title prefix (e.g. "TECH Spec:", "UC Spec:")
+  let type: Spec["type"] = "TECH";
+  if (/^UC\b/i.test(rawTitle)) type = "UC";
+  else if (/^TECH\b/i.test(rawTitle)) type = "TECH";
+  else if (/^DD\b|^ADR\b/i.test(rawTitle)) type = "DD";
+  else if (/^DQ\b/i.test(rawTitle)) type = "DQ";
+  else if (/^ACT\b/i.test(rawTitle)) type = "ACT";
+
+  const title = rawTitle.replace(/^(UC|TECH|DD|ADR|DQ|ACT)\s+Spec[:：]?\s*/i, "").trim();
+
+  // Fields
+  const fields: Record<string, string> = {};
+  for (const line of lines) {
+    const m = line.match(FIELD_RE);
+    if (m) fields[m[1].trim().toLowerCase()] = m[2].trim();
+  }
+
+  const status = (fields["status"] ?? "draft") as Spec["status"];
+  const migratedTo = fields["migrated_to"] ?? fields["migrated to"] ?? undefined;
+
+  // DD references
+  const decisionRefs: string[] = [];
+  const resolves = fields["resolves"] ?? "";
+  // Also scan session links for DD refs
+  const allText = content;
+  for (const match of allText.matchAll(DD_REF_RE)) {
+    if (!decisionRefs.includes(match[0])) decisionRefs.push(match[0]);
+  }
+
+  return {
+    node: {
+      id: stem,
+      title,
+      type,
+      status,
+      decision_refs: decisionRefs,
+      migrated_to: migratedTo,
+      file_path: filePath,
+      content,
+    },
+    confidence: title ? 1.0 : 0.5,
+    warnings,
+    source: { file: filePath },
+  };
+}

package/parser/state-detector.ts

@@ -0,0 +1,379 @@
+// State detector — detect DRE install state and project phase for each project
+
+import { readFileSync, existsSync, readdirSync } from "node:fs";
+import { execSync } from "node:child_process";
+import path from "node:path";
+
+// ─── DRE Install State ───
+
+export type DREInstallState = "FRESH" | "INSTALLED" | "CUSTOMIZED" | "OUTDATED" | "UNKNOWN";
+
+export interface DREState {
+  installState: DREInstallState;
+  localVersion: string | null;
+  kitVersion: string | null;
+  customizedFiles: string[];
+  totalFiles: number;
+}
+
+export function detectDREState(projectPath: string): DREState {
+  const claudeDir = path.join(projectPath, ".claude");
+  const dreVersionFile = path.join(claudeDir, ".dre-version");
+
+  // Check if .claude/ exists
+  if (!existsSync(claudeDir)) {
+    return { installState: "FRESH", localVersion: null, kitVersion: null, customizedFiles: [], totalFiles: 0 };
+  }
+
+  // Read local version
+  const localVersion = existsSync(dreVersionFile)
+    ? readFileSync(dreVersionFile, "utf-8").trim()
+    : null;
+
+  if (!localVersion) {
+    return { installState: "FRESH", localVersion: null, kitVersion: null, customizedFiles: [], totalFiles: 0 };
+  }
+
+  // Try to find kit version
+  let kitVersion: string | null = null;
+  const kitVersionPaths = [
+    path.join(projectPath, "dre", "kit", "version.txt"),
+    path.join(projectPath, "node_modules", "@unlaxer", "dre-toolkit", "version.txt"),
+  ];
+  for (const p of kitVersionPaths) {
+    if (existsSync(p)) {
+      kitVersion = readFileSync(p, "utf-8").trim();
+      break;
+    }
+  }
+
+  // Count files and detect customizations
+  const dirs = ["rules", "skills", "agents", "commands", "profiles"];
+  let totalFiles = 0;
+  const customizedFiles: string[] = [];
+
+  for (const dir of dirs) {
+    const localDir = path.join(claudeDir, dir);
+    if (!existsSync(localDir)) continue;
+
+    const files = readdirSync(localDir).filter((f) => f.endsWith(".md"));
+    totalFiles += files.length;
+
+    // Check if any files differ from kit
+    const kitDir = kitVersionPaths[0]
+      ? path.join(path.dirname(kitVersionPaths[0]), "..", "kit", dir)
+      : null;
+
+    if (kitDir && existsSync(kitDir)) {
+      for (const file of files) {
+        const localFile = path.join(localDir, file);
+        const kitFile = path.join(kitDir, file);
+        if (existsSync(kitFile)) {
+          try {
+            const localContent = readFileSync(localFile, "utf-8");
+            const kitContent = readFileSync(kitFile, "utf-8");
+            if (localContent !== kitContent) {
+              customizedFiles.push(`${dir}/${file}`);
+            }
+          } catch { /* ignore */ }
+        }
+      }
+    }
+  }
+
+  // Determine state
+  let installState: DREInstallState = "INSTALLED";
+  if (kitVersion && localVersion !== kitVersion) {
+    installState = "OUTDATED";
+  } else if (customizedFiles.length > 0) {
+    installState = "CUSTOMIZED";
+  }
+
+  return { installState, localVersion, kitVersion, customizedFiles, totalFiles };
+}
+
+// ─── Development Phase ───
+
+export type DevPhase = "spec" | "implementation" | "stabilization" | "maintenance" | "unknown";
+
+export interface PhaseState {
+  phase: DevPhase;
+  source: string;  // where was phase detected
+}
+
+export function detectPhase(projectPath: string): PhaseState {
+  // 1. Check CLAUDE.md for active_phase
+  const claudeMd = path.join(projectPath, ".claude", "CLAUDE.md");
+  if (existsSync(claudeMd)) {
+    const content = readFileSync(claudeMd, "utf-8");
+    const match = content.match(/active_phase[:：]\s*(spec|implementation|stabilization|maintenance)/i);
+    if (match) {
+      return { phase: match[1].toLowerCase() as DevPhase, source: ".claude/CLAUDE.md" };
+    }
+  }
+
+  // 2. Check CLAUDE.md at root
+  const rootClaude = path.join(projectPath, "CLAUDE.md");
+  if (existsSync(rootClaude)) {
+    const content = readFileSync(rootClaude, "utf-8");
+    const match = content.match(/active_phase[:：]\s*(spec|implementation|stabilization|maintenance)/i);
+    if (match) {
+      return { phase: match[1].toLowerCase() as DevPhase, source: "CLAUDE.md" };
+    }
+  }
+
+  // 3. Heuristic: check git commit messages for phase prefixes
+  try {
+    const log = execSync("git log --oneline -20", {
+      cwd: projectPath, encoding: "utf-8", timeout: 5000,
+    }).trim();
+
+    const lines = log.split("\n");
+    const prefixes = lines.map((l) => {
+      const m = l.match(/^\w+ (hotfix|fix|feat|docs|spec|test|refactor)[:(!]/);
+      return m?.[1] ?? null;
+    }).filter(Boolean) as string[];
+
+    if (prefixes.length === 0) return { phase: "unknown", source: "no commits" };
+
+    // Count prefix types
+    const counts: Record<string, number> = {};
+    for (const p of prefixes) counts[p] = (counts[p] ?? 0) + 1;
+
+    if (counts["hotfix"]) return { phase: "maintenance", source: "git log (hotfix commits)" };
+    if ((counts["fix"] ?? 0) + (counts["test"] ?? 0) > (counts["feat"] ?? 0)) {
+      return { phase: "stabilization", source: "git log (fix/test > feat)" };
+    }
+    if ((counts["docs"] ?? 0) + (counts["spec"] ?? 0) > (counts["feat"] ?? 0)) {
+      return { phase: "spec", source: "git log (docs/spec dominant)" };
+    }
+    return { phase: "implementation", source: "git log (feat dominant)" };
+  } catch {
+    return { phase: "unknown", source: "git not available" };
+  }
+}
+
+// ─── DRE Workflow State Machine ───
+
+export interface SMPhase {
+  id: string;
+  source: "base" | "plugin";
+  plugin?: string;       // "dge" | "dde" etc.
+  active: boolean;
+}
+
+export interface SubState {
+  id: string;
+  description: string;
+  active: boolean;
+}
+
+export interface PluginSM {
+  plugin: string;
+  phaseId: string;
+  states: SubState[];
+  current: string | null;
+}
+
+export interface WorkflowState {
+  phases: SMPhase[];
+  currentPhase: string;
+  currentSource: string;
+  subState: string | null;
+  stack: string[];
+  plugins: { id: string; version: string | null; phase: string; insertAfter: string }[];
+  pluginSMs: PluginSM[];
+}
+
+const BASE_PHASES = ["backlog", "spec", "impl", "review", "release"];
+
+const PLUGIN_DEFS: { dir: string; id: string; phase: string; insertAfter: string }[] = [
+  { dir: "dge", id: "dge", phase: "gap_extraction", insertAfter: "spec" },
+  { dir: "dde", id: "dde", phase: "doc_deficit_check", insertAfter: "review" },
+];
+
+function readYamlSM(projectPath: string): { phases: string[]; pluginPhases: Record<string, string> } | null {
+  const smPath = path.join(projectPath, ".dre", "state-machine.yaml");
+  if (!existsSync(smPath)) return null;
+  // Simple line-based YAML parse (avoid dependency)
+  const content = readFileSync(smPath, "utf-8");
+  const phases: string[] = [];
+  const pluginPhases: Record<string, string> = {};
+  let inPhases = false;
+  for (const line of content.split("\n")) {
+    if (/^phases:/.test(line)) { inPhases = true; continue; }
+    if (inPhases) {
+      const idMatch = line.match(/^\s+-\s+id:\s*(\S+)/);
+      if (idMatch) phases.push(idMatch[1]);
+      const pluginMatch = line.match(/^\s+-\s+(\w+)\s*#\s*(\w+)/);
+      if (pluginMatch) pluginPhases[pluginMatch[2]] = pluginMatch[1];
+    }
+  }
+  return phases.length > 0 ? { phases, pluginPhases } : null;
+}
+
+interface ContextData {
+  stack: string[];
+  current_phase: string | null;
+  sub_state: string | null;
+  plugins_sm: Record<string, { plugin: string; states: { id: string; next: string | null; description: string }[]; current: string | null }>;
+}
+
+function readContextJson(projectPath: string): ContextData | null {
+  const ctxPath = path.join(projectPath, ".dre", "context.json");
+  if (!existsSync(ctxPath)) return null;
+  try {
+    const data = JSON.parse(readFileSync(ctxPath, "utf-8"));
+    return {
+      stack: data.stack ?? [],
+      current_phase: data.current_phase ?? null,
+      sub_state: data.sub_state ?? null,
+      plugins_sm: data.plugins_sm ?? {},
+    };
+  } catch { return null; }
+}
+
+export function detectWorkflowState(projectPath: string): WorkflowState {
+  // 1. Try real state-machine.yaml
+  const yamlSM = readYamlSM(projectPath);
+
+  // 2. Detect installed plugins
+  const detectedPlugins: WorkflowState["plugins"] = [];
+  for (const pdef of PLUGIN_DEFS) {
+    const pluginDir = path.join(projectPath, pdef.dir);
+    if (existsSync(pluginDir)) {
+      let version: string | null = null;
+      const versionFiles = [
+        path.join(pluginDir, "kit", "version.txt"),
+        path.join(pluginDir, "version.txt"),
+      ];
+      for (const vf of versionFiles) {
+        if (existsSync(vf)) { version = readFileSync(vf, "utf-8").trim(); break; }
+      }
+      detectedPlugins.push({ ...pdef, version });
+    }
+  }
+
+  // 3. Build phase list
+  let phases: SMPhase[];
+  if (yamlSM) {
+    // Use real SM definition
+    phases = yamlSM.phases.map((id) => {
+      const pluginId = Object.entries(yamlSM.pluginPhases).find(([, phase]) => phase === id)?.[0];
+      return {
+        id,
+        source: pluginId ? "plugin" as const : "base" as const,
+        plugin: pluginId,
+        active: false,
+      };
+    });
+  } else {
+    // Build from defaults + detected plugins
+    const phaseList: SMPhase[] = BASE_PHASES.map((id) => ({
+      id, source: "base" as const, active: false,
+    }));
+
+    // Insert plugin phases
+    for (const plugin of detectedPlugins) {
+      const insertIdx = phaseList.findIndex((p) => p.id === plugin.insertAfter);
+      if (insertIdx >= 0) {
+        phaseList.splice(insertIdx + 1, 0, {
+          id: plugin.phase,
+          source: "plugin",
+          plugin: plugin.id,
+          active: false,
+        });
+      }
+    }
+    phases = phaseList;
+  }
+
+  // 4. Determine current phase + sub-state
+  let currentPhase = "unknown";
+  let currentSource = "not detected";
+  let subState: string | null = null;
+  let stack: string[] = [];
+  const pluginSMs: PluginSM[] = [];
+
+  // Priority 1: .dre/context.json (runtime state)
+  const ctx = readContextJson(projectPath);
+  if (ctx && ctx.stack.length > 0) {
+    currentPhase = ctx.current_phase ?? ctx.stack[ctx.stack.length - 1].toLowerCase();
+    currentSource = ".dre/context.json";
+    stack = ctx.stack;
+    subState = ctx.sub_state;
+
+    // Extract plugin sub-state machines
+    for (const [phaseId, psm] of Object.entries(ctx.plugins_sm ?? {})) {
+      pluginSMs.push({
+        plugin: psm.plugin,
+        phaseId,
+        states: (psm.states ?? []).map((s: any) => ({
+          id: s.id,
+          description: s.description ?? "",
+          active: s.id === psm.current,
+        })),
+        current: psm.current,
+      });
+    }
+  } else {
+    // Priority 2: CLAUDE.md active_phase
+    const phaseResult = detectPhase(projectPath);
+    if (phaseResult.phase !== "unknown") {
+      const phaseMap: Record<string, string> = {
+        spec: "spec", implementation: "impl",
+        stabilization: "review", maintenance: "release",
+      };
+      currentPhase = phaseMap[phaseResult.phase] ?? phaseResult.phase;
+      currentSource = phaseResult.source;
+    }
+  }
+
+  // Mark active phase
+  for (const phase of phases) {
+    phase.active = phase.id === currentPhase;
+  }
+
+  return { phases, currentPhase, currentSource, subState, stack, plugins: detectedPlugins, pluginSMs };
+}
+
+// ─── Combined Project State ───
+
+export interface ProjectState {
+  projectName: string;
+  projectPath: string;
+  dre: DREState;
+  phase: PhaseState;
+  workflow: WorkflowState;
+  dgeSessionCount: number;
+  ddCount: number;
+  lastSessionDate: string | null;
+}
+
+export function detectProjectState(projectName: string, projectPath: string): ProjectState {
+  const dre = detectDREState(projectPath);
+  const phase = detectPhase(projectPath);
+  const workflow = detectWorkflowState(projectPath);
+
+  const sessionsDir = path.join(projectPath, "dge", "sessions");
+  const decisionsDir = path.join(projectPath, "dge", "decisions");
+
+  let dgeSessionCount = 0;
+  let ddCount = 0;
+  let lastSessionDate: string | null = null;
+
+  if (existsSync(sessionsDir)) {
+    const files = readdirSync(sessionsDir).filter((f) => f.endsWith(".md") && f !== "index.md");
+    dgeSessionCount = files.length;
+    const dates = files
+      .map((f) => f.match(/^(\d{4}-\d{2}-\d{2})/)?.[1])
+      .filter(Boolean) as string[];
+    if (dates.length > 0) lastSessionDate = dates.sort().reverse()[0];
+  }
+
+  if (existsSync(decisionsDir)) {
+    ddCount = readdirSync(decisionsDir).filter((f) => f.endsWith(".md") && f !== "index.md").length;
+  }
+
+  return { projectName, projectPath, dre, phase, workflow, dgeSessionCount, ddCount, lastSessionDate };
+}