iikit-dashboard 1.0.0

package/src/pipeline.js

@@ -0,0 +1,130 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { parseTasks, parseChecklists, parseConstitutionTDD, hasClarifications } = require('./parser');
+
+/**
+ * Compute pipeline phase states for a feature by examining artifacts on disk.
+ *
+ * @param {string} projectPath - Path to the project root
+ * @param {string} featureId - Feature directory name (e.g., "001-kanban-board")
+ * @returns {{phases: Array<{id: string, name: string, status: string, progress: string|null, optional: boolean}>}}
+ */
+function computePipelineState(projectPath, featureId) {
+  const featureDir = path.join(projectPath, 'specs', featureId);
+  const constitutionPath = path.join(projectPath, 'CONSTITUTION.md');
+  const specPath = path.join(featureDir, 'spec.md');
+  const planPath = path.join(featureDir, 'plan.md');
+  const checklistDir = path.join(featureDir, 'checklists');
+  const testSpecsPath = path.join(featureDir, 'tests', 'test-specs.md');
+  const tasksPath = path.join(featureDir, 'tasks.md');
+
+  const analysisPath = path.join(featureDir, 'analysis.md');
+
+  const specExists = fs.existsSync(specPath);
+  const planExists = fs.existsSync(planPath);
+  const tasksExists = fs.existsSync(tasksPath);
+  const testSpecsExists = fs.existsSync(testSpecsPath);
+  const constitutionExists = fs.existsSync(constitutionPath);
+  const analysisExists = fs.existsSync(analysisPath);
+
+  // Read spec content for clarifications check
+  const specContent = specExists ? fs.readFileSync(specPath, 'utf-8') : '';
+
+  // Parse tasks for implement progress
+  const tasksContent = tasksExists ? fs.readFileSync(tasksPath, 'utf-8') : '';
+  const tasks = parseTasks(tasksContent);
+  const checkedCount = tasks.filter(t => t.checked).length;
+  const totalCount = tasks.length;
+
+  // Parse checklists
+  const checklistStatus = parseChecklists(checklistDir);
+
+  // TDD requirement check
+  const tddRequired = constitutionExists ? parseConstitutionTDD(constitutionPath) : false;
+
+  const phases = [
+    {
+      id: 'constitution',
+      name: 'Constitution',
+      status: constitutionExists ? 'complete' : 'not_started',
+      progress: null,
+      optional: false
+    },
+    {
+      id: 'spec',
+      name: 'Spec',
+      status: specExists ? 'complete' : 'not_started',
+      progress: null,
+      optional: false
+    },
+    {
+      id: 'clarify',
+      name: 'Clarify',
+      status: hasClarifications(specContent) ? 'complete' : (planExists && !hasClarifications(specContent) ? 'skipped' : 'not_started'),
+      progress: null,
+      optional: true
+    },
+    {
+      id: 'plan',
+      name: 'Plan',
+      status: planExists ? 'complete' : 'not_started',
+      progress: null,
+      optional: false
+    },
+    {
+      id: 'checklist',
+      name: 'Checklist',
+      status: checklistStatus.total === 0
+        ? 'not_started'
+        : checklistStatus.checked === checklistStatus.total
+          ? 'complete'
+          : 'in_progress',
+      progress: checklistStatus.total > 0
+        ? `${Math.round((checklistStatus.checked / checklistStatus.total) * 100)}%`
+        : null,
+      optional: false
+    },
+    {
+      id: 'testify',
+      name: 'Testify',
+      status: testSpecsExists
+        ? 'complete'
+        : (!tddRequired && planExists ? 'skipped' : 'not_started'),
+      progress: null,
+      optional: !tddRequired
+    },
+    {
+      id: 'tasks',
+      name: 'Tasks',
+      status: tasksExists ? 'complete' : 'not_started',
+      progress: null,
+      optional: false
+    },
+    {
+      id: 'analyze',
+      name: 'Analyze',
+      status: analysisExists ? 'complete' : 'not_started',
+      progress: null,
+      optional: false
+    },
+    {
+      id: 'implement',
+      name: 'Implement',
+      status: totalCount === 0 || checkedCount === 0
+        ? 'not_started'
+        : checkedCount === totalCount
+          ? 'complete'
+          : 'in_progress',
+      progress: totalCount > 0 && checkedCount > 0
+        ? `${Math.round((checkedCount / totalCount) * 100)}%`
+        : null,
+      optional: false
+    }
+  ];
+
+  return { phases };
+}
+
+module.exports = { computePipelineState };

package/src/planview.js

@@ -0,0 +1,195 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { parseTechContext, parseFileStructure, parseAsciiDiagram, parseTesslJson, parseResearchDecisions } = require('./parser');
+
+module.exports = { computePlanViewState, classifyNodeTypes };
+
+// In-memory cache for LLM classification results per feature
+const classificationCache = new Map();
+
+/**
+ * Compute plan view state from parsed plan.md data.
+ * Follows the same pattern as board.js and storymap.js.
+ *
+ * @param {string} projectPath - Path to project root
+ * @param {string} featureId - Feature directory name
+ * @returns {Promise<Object>} Plan view state
+ */
+async function computePlanViewState(projectPath, featureId) {
+  const featureDir = path.join(projectPath, 'specs', featureId);
+  const planPath = path.join(featureDir, 'plan.md');
+
+  if (!fs.existsSync(planPath)) {
+    return {
+      techContext: [],
+      researchDecisions: [],
+      fileStructure: null,
+      diagram: null,
+      tesslTiles: [],
+      exists: false,
+    };
+  }
+
+  const planContent = fs.readFileSync(planPath, 'utf-8');
+
+  // Parse tech context
+  const techContext = parseTechContext(planContent);
+
+  // Parse research decisions for tooltips
+  const researchPath = path.join(featureDir, 'research.md');
+  let researchDecisions = [];
+  if (fs.existsSync(researchPath)) {
+    const researchContent = fs.readFileSync(researchPath, 'utf-8');
+    researchDecisions = parseResearchDecisions(researchContent);
+  }
+
+  // Parse file structure and check existence
+  let fileStructure = parseFileStructure(planContent);
+  if (fileStructure) {
+    fileStructure.entries = fileStructure.entries.map(entry => {
+      const filePath = buildFilePath(fileStructure.entries, entry, fileStructure.rootName);
+      const fullPath = path.join(projectPath, filePath);
+      return { ...entry, exists: fs.existsSync(fullPath) };
+    });
+  }
+
+  // Parse ASCII diagram
+  let diagram = parseAsciiDiagram(planContent);
+  if (diagram && diagram.nodes.length > 0) {
+    // Classify node types via LLM (with cache and fallback)
+    const cacheKey = `${featureId}:${planContent.length}`;
+    if (classificationCache.has(cacheKey)) {
+      const cached = classificationCache.get(cacheKey);
+      diagram.nodes = diagram.nodes.map(n => ({
+        ...n,
+        type: cached[n.label] || 'default'
+      }));
+    } else {
+      const labels = diagram.nodes.map(n => n.label);
+      const types = await classifyNodeTypes(labels);
+      classificationCache.set(cacheKey, types);
+      diagram.nodes = diagram.nodes.map(n => ({
+        ...n,
+        type: types[n.label] || 'default'
+      }));
+    }
+  }
+
+  // Parse tessl.json
+  const tesslTiles = parseTesslJson(projectPath);
+
+  return {
+    techContext,
+    researchDecisions,
+    fileStructure,
+    diagram,
+    tesslTiles,
+    exists: true,
+  };
+}
+
+/**
+ * Build file path from tree entries by walking up the depth chain.
+ */
+function buildFilePath(entries, targetEntry, rootName) {
+  const idx = entries.indexOf(targetEntry);
+  const parts = [targetEntry.name];
+  let currentDepth = targetEntry.depth;
+
+  // Walk backwards to find all parent directories
+  for (let i = idx - 1; i >= 0; i--) {
+    if (entries[i].depth < currentDepth && entries[i].type === 'directory') {
+      parts.unshift(entries[i].name);
+      currentDepth = entries[i].depth;
+      if (currentDepth === 0) break;
+    }
+  }
+
+  // If entry is at depth 0 and has no directory parent, prepend rootName
+  if (currentDepth === 0 && rootName && parts[0] !== rootName) {
+    // Check if the entry is NOT under a different depth-0 directory
+    // (i.e., it belongs to the rootName section)
+    let hasDepth0DirParent = false;
+    for (let i = idx - 1; i >= 0; i--) {
+      if (entries[i].depth === 0 && entries[i].type === 'directory') {
+        hasDepth0DirParent = true;
+        break;
+      }
+    }
+    if (!hasDepth0DirParent) {
+      parts.unshift(rootName);
+    }
+  }
+
+  return parts.join('/');
+}
+
+/**
+ * Classify diagram node labels into component types using LLM.
+ * Falls back to all "default" if API key is missing or call fails.
+ *
+ * @param {string[]} labels - Node labels to classify
+ * @returns {Promise<Object>} Mapping of label -> type
+ */
+async function classifyNodeTypes(labels) {
+  const result = {};
+  for (const label of labels) result[label] = 'default';
+
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey || labels.length === 0) return result;
+
+  try {
+    const Anthropic = require('@anthropic-ai/sdk');
+    const client = new Anthropic({ apiKey });
+
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
+
+    const response = await client.messages.create({
+      model: 'claude-haiku-4-5-20251001',
+      max_tokens: 256,
+      messages: [{
+        role: 'user',
+        content: `Classify each of these software architecture diagram component labels into exactly one category: "client", "server", "storage", or "external".
+
+Labels: ${JSON.stringify(labels)}
+
+Respond with ONLY a JSON object mapping each label to its category. Example: {"Browser": "client", "API Server": "server"}
+No explanation, just the JSON.`
+      }]
+    }, { signal: controller.signal });
+
+    clearTimeout(timeout);
+
+    const text = response.content[0]?.text || '';
+    const jsonMatch = text.match(/\{[\s\S]*\}/);
+    if (jsonMatch) {
+      const parsed = JSON.parse(jsonMatch[0]);
+      const validTypes = new Set(['client', 'server', 'storage', 'external']);
+      for (const [label, type] of Object.entries(parsed)) {
+        if (validTypes.has(type)) {
+          result[label] = type;
+        }
+      }
+    }
+  } catch {
+    // Fallback: all nodes get "default" type
+  }
+
+  return result;
+}
+
+/**
+ * Invalidate classification cache for a feature.
+ */
+function invalidateCache(featureId) {
+  for (const key of classificationCache.keys()) {
+    if (key.startsWith(`${featureId}:`)) {
+      classificationCache.delete(key);
+    }
+  }
+}
+
+module.exports.invalidateCache = invalidateCache;