@unlaxer/dve-toolkit 4.1.0

package/config.ts

@@ -0,0 +1,64 @@
+// DVE configuration — multi-project support
+
+import { readFileSync, existsSync } from "node:fs";
+import path from "node:path";
+
+export interface ProjectConfig {
+  name: string;
+  path: string;        // absolute path to project root
+  sessionsDir: string; // relative to path, default "dge/sessions"
+  decisionsDir: string;
+  specsDir: string;
+  annotationsDir: string;
+}
+
+export interface DVEConfig {
+  projects: ProjectConfig[];
+  outputDir: string;   // where graph files go
+}
+
+const DEFAULT_DIRS = {
+  sessionsDir: "dge/sessions",
+  decisionsDir: "dge/decisions",
+  specsDir: "dge/specs",
+  annotationsDir: "dve/annotations",
+};
+
+export function loadConfig(configPath: string): DVEConfig | null {
+  if (!existsSync(configPath)) return null;
+  const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+  return {
+    outputDir: raw.outputDir ?? "dve/dist",
+    projects: (raw.projects ?? []).map((p: any) => ({
+      name: p.name ?? path.basename(p.path),
+      path: path.resolve(path.dirname(configPath), p.path),
+      sessionsDir: p.sessionsDir ?? DEFAULT_DIRS.sessionsDir,
+      decisionsDir: p.decisionsDir ?? DEFAULT_DIRS.decisionsDir,
+      specsDir: p.specsDir ?? DEFAULT_DIRS.specsDir,
+      annotationsDir: p.annotationsDir ?? DEFAULT_DIRS.annotationsDir,
+    })),
+  };
+}
+
+export function singleProjectConfig(cwd: string): DVEConfig {
+  return {
+    outputDir: path.join(cwd, "dve", "dist"),
+    projects: [
+      {
+        name: path.basename(cwd),
+        path: cwd,
+        ...DEFAULT_DIRS,
+      },
+    ],
+  };
+}
+
+export function resolveProjectDirs(project: ProjectConfig) {
+  return {
+    sessionsDir: path.join(project.path, project.sessionsDir),
+    decisionsDir: path.join(project.path, project.decisionsDir),
+    specsDir: path.join(project.path, project.specsDir),
+    annotationsDir: path.join(project.path, project.annotationsDir),
+    cwd: project.path,
+  };
+}

package/context/bundle.ts

@@ -0,0 +1,142 @@
+// ContextBundle generator — DVE → DGE bridge
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import path from "node:path";
+import type { DVEGraph, GraphNode, ContextBundle, Gap, Decision, Session } from "../graph/schema.js";
+import { traceDecision } from "../graph/query.js";
+
+export interface BundleOptions {
+  graph: DVEGraph;
+  originId: string;
+  constraints?: string[];
+  outputDir: string;
+}
+
+function findNode(graph: DVEGraph, id: string): GraphNode | undefined {
+  return graph.nodes.find((n) => n.id === id);
+}
+
+function sessionGaps(graph: DVEGraph, sessionId: string): GraphNode[] {
+  const gapIds = graph.edges
+    .filter((e) => e.source === sessionId && e.type === "discovers")
+    .map((e) => e.target);
+  return graph.nodes.filter((n) => gapIds.includes(n.id));
+}
+
+function relatedDecisions(graph: DVEGraph, sessionId: string): GraphNode[] {
+  const gaps = sessionGaps(graph, sessionId);
+  const ddIds = new Set<string>();
+  for (const gap of gaps) {
+    const resolves = graph.edges.filter((e) => e.source === gap.id && e.type === "resolves");
+    for (const edge of resolves) ddIds.add(edge.target);
+  }
+  return graph.nodes.filter((n) => ddIds.has(n.id));
+}
+
+function relatedAnnotations(graph: DVEGraph, targetId: string): GraphNode[] {
+  const annIds = graph.edges
+    .filter((e) => e.target === targetId && e.type === "annotates")
+    .map((e) => e.source);
+  return graph.nodes.filter((n) => annIds.includes(n.id));
+}
+
+export function generateBundle(opts: BundleOptions): ContextBundle {
+  const { graph, originId, constraints = [], outputDir } = opts;
+  const origin = findNode(graph, originId);
+  if (!origin) throw new Error(`Node not found: ${originId}`);
+
+  // Find related session
+  let sessionNode: GraphNode | undefined;
+  let sessionData: Partial<Session> = {};
+
+  if (origin.type === "session") {
+    sessionNode = origin;
+  } else if (origin.type === "gap") {
+    const gapData = origin.data as Partial<Gap>;
+    sessionNode = findNode(graph, gapData.session_id ?? "");
+  } else if (origin.type === "decision") {
+    const ddData = origin.data as Partial<Decision>;
+    const sessionRef = ddData.session_refs?.[0];
+    if (sessionRef) sessionNode = findNode(graph, sessionRef);
+  }
+
+  if (sessionNode) sessionData = sessionNode.data as Partial<Session>;
+
+  // Gather context
+  const gaps = sessionNode ? sessionGaps(graph, sessionNode.id) : [];
+  const decisions = sessionNode ? relatedDecisions(graph, sessionNode.id) : [];
+  const annotations = relatedAnnotations(graph, originId);
+
+  // Determine action
+  let suggestedAction: ContextBundle["suggested_action"] = "revisit";
+  if (origin.type === "gap") suggestedAction = "deep_dive";
+  if (constraints.length > 0) suggestedAction = "new_angle";
+
+  // Sessions date range
+  const dates = [sessionData.date].filter(Boolean) as string[];
+  const dateRange = dates.length > 0 ? dates.join(" ~ ") : "unknown";
+
+  // Build prompt template
+  const originLabel =
+    origin.type === "decision"
+      ? `${origin.id} (${(origin.data as any).title})`
+      : origin.type === "gap"
+        ? `Gap "${(origin.data as any).summary?.slice(0, 60)}"`
+        : `Session "${sessionData.theme}"`;
+
+  const priorDDs = decisions.map((d) => `${d.id}: ${(d.data as any).title}`);
+  const priorGaps = gaps.slice(0, 5).map((g) => {
+    const gd = g.data as Partial<Gap>;
+    return `${g.id.split("#")[1]}: ${gd.summary?.slice(0, 50)}`;
+  });
+
+  let prompt = `${originLabel} を再検討。\n`;
+  if (priorDDs.length > 0) prompt += `前回の決定: ${priorDDs.join(", ")}。\n`;
+  if (priorGaps.length > 0) prompt += `前回の Gap: ${priorGaps.join("; ")}。\n`;
+  if (sessionData.characters?.length) {
+    prompt += `前回のキャラ: ${sessionData.characters.join(", ")}。\n`;
+  }
+  if (constraints.length > 0) {
+    prompt += `追加制約: ${constraints.join("; ")}。\n`;
+  }
+  prompt += `この文脈を踏まえて DGE して。`;
+
+  const bundle: ContextBundle = {
+    type: "dve-context-bundle",
+    version: "1.0.0",
+    origin: {
+      node_type: origin.type as any,
+      node_id: origin.id,
+      file: (origin.data as any).file_path ?? "",
+    },
+    summary: {
+      theme: sessionData.theme ?? "unknown",
+      date_range: dateRange,
+      prior_decisions: priorDDs,
+      prior_gaps: gaps.map((g) => ({
+        id: g.id,
+        summary: (g.data as any).summary ?? "",
+        status: (g.data as any).status ?? "Active",
+      })),
+      characters_used: sessionData.characters ?? [],
+      session_count: 1,
+    },
+    new_constraints: constraints,
+    annotations: annotations.map((a) => ({
+      date: (a.data as any).date ?? "",
+      action: (a.data as any).action ?? "comment",
+      body: (a.data as any).body ?? "",
+    })),
+    suggested_action: suggestedAction,
+    prompt_template: prompt,
+  };
+
+  // Save to file
+  mkdirSync(outputDir, { recursive: true });
+  const slug = originId.replace(/[^a-zA-Z0-9-]/g, "_");
+  const filename = `ctx-${new Date().toISOString().split("T")[0]}-${slug}.json`;
+  const outPath = path.join(outputDir, filename);
+  writeFileSync(outPath, JSON.stringify(bundle, null, 2));
+
+  return bundle;
+}

package/graph/builder.ts

@@ -0,0 +1,254 @@
+// Graph builder — assemble nodes + edges from parse results
+
+import { readdirSync, existsSync } from "node:fs";
+import path from "node:path";
+import { parseSession } from "../parser/session-parser.js";
+import { parseDecision } from "../parser/decision-parser.js";
+import { parseAnnotation } from "../parser/annotation-parser.js";
+import { parseSpec } from "../parser/spec-parser.js";
+import { gitLinkerEdges } from "../parser/git-linker.js";
+import { buildGlossary } from "../parser/glossary-builder.js";
+import type { DVEGraph, GraphNode, Edge } from "./schema.js";
+
+export interface BuildOptions {
+  sessionsDir: string;
+  decisionsDir: string;
+  specsDir: string;
+  annotationsDir: string;
+  cwd: string;
+  enableGitLinker?: boolean;
+}
+
+function scanMd(dir: string): string[] {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter((f) => f.endsWith(".md") && f !== "index.md")
+    .map((f) => path.join(dir, f))
+    .sort();
+}
+
+export function buildGraph(opts: BuildOptions): DVEGraph {
+  const nodes: GraphNode[] = [];
+  const edges: Edge[] = [];
+  const warnings: { file: string; message: string }[] = [];
+
+  // 1. Parse sessions
+  const sessionFiles = scanMd(opts.sessionsDir);
+  for (const file of sessionFiles) {
+    const { session, gaps } = parseSession(file);
+    if (session.node.id) {
+      nodes.push({
+        type: "session",
+        id: session.node.id!,
+        data: session.node as any,
+        confidence: session.confidence,
+        warnings: session.warnings,
+      });
+      for (const w of session.warnings) {
+        warnings.push({ file, message: w });
+      }
+    }
+
+    // Dialogue node — sits between Session and Gaps
+    const dialogueId = `${session.node.id!}#dialogue`;
+    const hasDialogue = !!(session.node as any).content &&
+      /Scene|先輩|ナレーション|☕|👤|🎩|😰|⚔|🎨|📊/.test((session.node as any).content ?? "");
+    nodes.push({
+      type: "dialogue" as any,
+      id: dialogueId,
+      data: {
+        session_id: session.node.id!,
+        has_content: hasDialogue,
+        scene_count: ((session.node as any).content?.match(/##.*Scene/g) ?? []).length,
+        char_count: ((session.node as any).content?.match(/☕|👤|🎩|😰|⚔|🎨|📊|🏥|😈|🧑‍💼/g) ?? []).length,
+      } as any,
+      confidence: hasDialogue ? 1.0 : 0.3,
+      warnings: hasDialogue ? [] : ["会話劇テキスト未保存"],
+    });
+    // Session → Dialogue
+    edges.push({
+      source: session.node.id!,
+      target: dialogueId,
+      type: "contains",
+      confidence: "explicit",
+    });
+
+    for (const gap of gaps) {
+      if (gap.node.id) {
+        nodes.push({
+          type: "gap",
+          id: gap.node.id!,
+          data: gap.node as any,
+          confidence: gap.confidence,
+          warnings: gap.warnings,
+        });
+        // Dialogue → Gap (instead of Session → Gap)
+        edges.push({
+          source: dialogueId,
+          target: gap.node.id!,
+          type: "discovers",
+          confidence: "explicit",
+        });
+        for (const w of gap.warnings) {
+          warnings.push({ file, message: `${gap.node.id}: ${w}` });
+        }
+      }
+    }
+  }
+
+  // 2. Parse decisions
+  const ddFiles = scanMd(opts.decisionsDir);
+  for (const file of ddFiles) {
+    const dd = parseDecision(file);
+    if (dd.node.id) {
+      nodes.push({
+        type: "decision",
+        id: dd.node.id!,
+        data: dd.node as any,
+        confidence: dd.confidence,
+        warnings: dd.warnings,
+      });
+      for (const w of dd.warnings) {
+        warnings.push({ file, message: `${dd.node.id}: ${w}` });
+      }
+
+      // resolves edges: find gaps that this DD references
+      // Match session_refs to gaps in those sessions
+      for (const sessionRef of dd.node.session_refs ?? []) {
+        const sessionGaps = nodes.filter(
+          (n) => n.type === "gap" && (n.data as any).session_id === sessionRef
+        );
+        // If DD has specific gap_refs (#N), match them
+        if (dd.node.gap_refs && dd.node.gap_refs.length > 0) {
+          for (const gapRef of dd.node.gap_refs) {
+            const gapNum = gapRef.replace("#", "");
+            const matchingGap = sessionGaps.find((g) =>
+              g.id.endsWith(`#G-${gapNum.padStart(3, "0")}`)
+            );
+            if (matchingGap) {
+              edges.push({
+                source: matchingGap.id,
+                target: dd.node.id!,
+                type: "resolves",
+                confidence: "explicit",
+                evidence: `DD references Gap ${gapRef}`,
+              });
+            }
+          }
+        } else {
+          // No specific gap refs — link DD to session (inferred)
+          edges.push({
+            source: sessionRef,
+            target: dd.node.id!,
+            type: "resolves",
+            confidence: "inferred",
+            evidence: "DD references session without specific gap numbers",
+          });
+        }
+      }
+
+      // supersedes edges
+      for (const sup of dd.node.supersedes ?? []) {
+        edges.push({
+          source: dd.node.id!,
+          target: sup,
+          type: "supersedes",
+          confidence: "explicit",
+        });
+      }
+    }
+  }
+
+  // 3. Parse annotations
+  const annFiles = scanMd(opts.annotationsDir);
+  for (const file of annFiles) {
+    const ann = parseAnnotation(file);
+    if (ann.node.id) {
+      nodes.push({
+        type: "annotation",
+        id: ann.node.id!,
+        data: ann.node as any,
+        confidence: ann.confidence,
+        warnings: ann.warnings,
+      });
+      // annotates edge
+      if (ann.node.target?.id) {
+        edges.push({
+          source: ann.node.id!,
+          target: ann.node.target.id,
+          type: "annotates",
+          confidence: "explicit",
+        });
+      }
+    }
+  }
+
+  // 4. Parse specs
+  const specFiles = scanMd(opts.specsDir);
+  for (const file of specFiles) {
+    const spec = parseSpec(file);
+    if (spec.node.id) {
+      nodes.push({
+        type: "spec",
+        id: spec.node.id!,
+        data: spec.node as any,
+        confidence: spec.confidence,
+        warnings: spec.warnings,
+      });
+      // produces edges: Decision → Spec
+      for (const ddRef of spec.node.decision_refs ?? []) {
+        if (nodes.some((n) => n.id === ddRef)) {
+          edges.push({
+            source: ddRef,
+            target: spec.node.id!,
+            type: "produces",
+            confidence: "inferred",
+            evidence: `Spec references ${ddRef}`,
+          });
+        }
+      }
+    }
+  }
+
+  // 5. Git linker
+  if (opts.enableGitLinker !== false) {
+    const ddIds = new Set(nodes.filter((n) => n.type === "decision").map((n) => n.id));
+    const gitEdges = gitLinkerEdges(opts.cwd, ddIds);
+    for (const edge of gitEdges) {
+      // Add commit as external ref node if not exists
+      if (!nodes.some((n) => n.id === edge.target)) {
+        nodes.push({
+          type: "annotation" as any, // reuse for external refs
+          id: edge.target,
+          data: { type: "commit", ref: edge.target, evidence: edge.evidence } as any,
+          confidence: 0.8,
+          warnings: [],
+        });
+      }
+      edges.push(edge);
+    }
+  }
+
+  // Stats
+  const stats = {
+    sessions: nodes.filter((n) => n.type === "session").length,
+    gaps: nodes.filter((n) => n.type === "gap").length,
+    decisions: nodes.filter((n) => n.type === "decision").length,
+    annotations: nodes.filter((n) => n.type === "annotation").length,
+    specs: nodes.filter((n) => n.type === "spec").length,
+  };
+
+  // Build glossary from completed graph
+  const partialGraph = { version: "1.0.0", generated_at: "", stats, nodes, edges, warnings } as DVEGraph;
+  const glossary = buildGlossary(partialGraph, opts.cwd);
+
+  return {
+    version: "1.0.0",
+    generated_at: new Date().toISOString(),
+    stats,
+    nodes,
+    edges,
+    warnings,
+    glossary: glossary.entries,
+  };
+}

package/graph/cluster.ts

@@ -0,0 +1,105 @@
+// Clustering — group decisions by supersedes chains and theme similarity
+
+import type { DVEGraph, GraphNode, Decision } from "./schema.js";
+
+export interface Cluster {
+  id: string;
+  label: string;
+  ddIds: string[];
+  gapCount: number;
+}
+
+// Group DDs by supersedes chains (connected components)
+export function clusterBySupersedes(graph: DVEGraph): Cluster[] {
+  const ddNodes = graph.nodes.filter((n) => n.type === "decision");
+  const supersedesEdges = graph.edges.filter((e) => e.type === "supersedes");
+
+  // Union-Find
+  const parent: Record<string, string> = {};
+  for (const dd of ddNodes) parent[dd.id] = dd.id;
+
+  function find(x: string): string {
+    if (parent[x] !== x) parent[x] = find(parent[x]);
+    return parent[x];
+  }
+  function union(a: string, b: string) {
+    const ra = find(a), rb = find(b);
+    if (ra !== rb) parent[ra] = rb;
+  }
+
+  for (const edge of supersedesEdges) {
+    if (parent[edge.source] !== undefined && parent[edge.target] !== undefined) {
+      union(edge.source, edge.target);
+    }
+  }
+
+  // Group by root
+  const groups: Record<string, string[]> = {};
+  for (const dd of ddNodes) {
+    const root = find(dd.id);
+    if (!groups[root]) groups[root] = [];
+    groups[root].push(dd.id);
+  }
+
+  // Build clusters
+  const clusters: Cluster[] = [];
+  for (const [root, ddIds] of Object.entries(groups)) {
+    // Find the latest DD's title as cluster label
+    const latestDD = ddIds
+      .map((id) => graph.nodes.find((n) => n.id === id))
+      .filter(Boolean)
+      .sort((a, b) => ((b!.data as any).date ?? "").localeCompare((a!.data as any).date ?? ""))
+      [0];
+
+    const label = (latestDD?.data as any)?.title ?? root;
+
+    // Count related gaps
+    const gapCount = ddIds.reduce((sum, ddId) => {
+      return sum + graph.edges.filter((e) => e.target === ddId && e.type === "resolves").length;
+    }, 0);
+
+    clusters.push({
+      id: `cluster-${root}`,
+      label: label.slice(0, 60),
+      ddIds,
+      gapCount,
+    });
+  }
+
+  return clusters.sort((a, b) => b.gapCount - a.gapCount);
+}
+
+// Simple keyword-based theme clustering for DDs not in supersedes chains
+export function clusterByTheme(graph: DVEGraph): Cluster[] {
+  const ddNodes = graph.nodes.filter((n) => n.type === "decision");
+  const keywords: Record<string, string[]> = {};
+
+  for (const dd of ddNodes) {
+    const title = ((dd.data as any).title ?? "").toLowerCase();
+    // Extract significant words (3+ chars, not common)
+    const words = title.split(/[\s\-_\/]+/).filter((w: string) => w.length >= 3);
+    for (const word of words) {
+      if (!keywords[word]) keywords[word] = [];
+      keywords[word].push(dd.id);
+    }
+  }
+
+  // Find keyword groups with 2+ DDs
+  const clusters: Cluster[] = [];
+  const used = new Set<string>();
+  for (const [word, ids] of Object.entries(keywords)) {
+    if (ids.length < 2) continue;
+    const uniqueIds = ids.filter((id) => !used.has(id));
+    if (uniqueIds.length < 2) continue;
+
+    for (const id of uniqueIds) used.add(id);
+    clusters.push({
+      id: `theme-${word}`,
+      label: word,
+      ddIds: uniqueIds,
+      gapCount: 0,
+    });
+  }
+
+  return clusters;
+}

package/graph/query.ts

@@ -0,0 +1,82 @@
+// Graph queries — traceDecision, impactOf, orphanGaps, overturned
+
+import type { DVEGraph, GraphNode, Edge, Gap, Decision } from "./schema.js";
+
+// Trace a decision back to its originating sessions and gaps
+export function traceDecision(graph: DVEGraph, ddId: string): GraphNode[] {
+  const chain: GraphNode[] = [];
+  const visited = new Set<string>();
+
+  function walkBack(nodeId: string) {
+    if (visited.has(nodeId)) return;
+    visited.add(nodeId);
+
+    const node = graph.nodes.find((n) => n.id === nodeId);
+    if (node) chain.push(node);
+
+    // Find edges where this node is the target
+    const incoming = graph.edges.filter((e) => e.target === nodeId);
+    for (const edge of incoming) {
+      walkBack(edge.source);
+    }
+  }
+
+  walkBack(ddId);
+  return chain;
+}
+
+// Forward traversal — find all nodes affected by a change to this node
+export function impactOf(graph: DVEGraph, nodeId: string): GraphNode[] {
+  const impacted: GraphNode[] = [];
+  const visited = new Set<string>();
+
+  function walkForward(nid: string) {
+    if (visited.has(nid)) return;
+    visited.add(nid);
+
+    const outgoing = graph.edges.filter((e) => e.source === nid);
+    for (const edge of outgoing) {
+      const target = graph.nodes.find((n) => n.id === edge.target);
+      if (target && !visited.has(target.id)) {
+        impacted.push(target);
+        walkForward(target.id);
+      }
+    }
+  }
+
+  walkForward(nodeId);
+  return impacted;
+}
+
+// Orphan gaps — gaps not linked to any decision
+export function orphanGaps(graph: DVEGraph): GraphNode[] {
+  const gapNodes = graph.nodes.filter((n) => n.type === "gap");
+  const resolvedGapIds = new Set(
+    graph.edges.filter((e) => e.type === "resolves").map((e) => e.source)
+  );
+  return gapNodes.filter((g) => !resolvedGapIds.has(g.id));
+}
+
+// Overturned decisions + their impact
+export function overturned(graph: DVEGraph): { decision: GraphNode; impact: GraphNode[] }[] {
+  const overturnedDDs = graph.nodes.filter(
+    (n) => n.type === "decision" && (n.data as Decision).status === "overturned"
+  );
+  return overturnedDDs.map((dd) => ({
+    decision: dd,
+    impact: impactOf(graph, dd.id),
+  }));
+}
+
+// Search nodes by keyword
+export function search(graph: DVEGraph, keyword: string): GraphNode[] {
+  const lower = keyword.toLowerCase();
+  return graph.nodes.filter((n) => {
+    const data = n.data as any;
+    const searchFields = [
+      data.title, data.theme, data.summary, data.body, data.rationale,
+      n.id,
+    ].filter(Boolean);
+    return searchFields.some((f: string) => f.toLowerCase().includes(lower));
+  });
+}