@assistkick/create 1.7.0 → 1.9.0

package/templates/assistkick-product-system/packages/shared/lib/workflow_orchestrator.ts

@@ -0,0 +1,211 @@
+/**
+ * WorkflowOrchestrator — runs the Play All loop server-side using WorkflowEngine.
+ * Iterates through TODO features sequentially, respecting dependency ordering.
+ * Continues across browser sessions. On server restart, does NOT auto-resume.
+ */
+
+import type { WorkflowEngine } from './workflow_engine.js';
+
+interface WorkflowOrchestratorDeps {
+  workflowEngine: WorkflowEngine;
+  loadKanban: (projectId?: string) => Promise<any>;
+  readGraph: (projectId?: string) => Promise<any>;
+  resolveDefaultWorkflow: (projectId?: string) => Promise<{ id: string } | null>;
+  log: (tag: string, ...args: any[]) => void;
+}
+
+export class WorkflowOrchestrator {
+  private workflowEngine: WorkflowEngine;
+  private loadKanban: (projectId?: string) => Promise<any>;
+  private readGraph: (projectId?: string) => Promise<any>;
+  private resolveDefaultWorkflow: (projectId?: string) => Promise<{ id: string } | null>;
+  private log: (tag: string, ...args: any[]) => void;
+
+  private active = false;
+  private aborted = false;
+  private currentFeatureId: string | null = null;
+  private projectId: string = '';
+  private epicId: string | null = null;
+  private processedCount = 0;
+  private skippedFeatures: string[] = [];
+
+  constructor({ workflowEngine, loadKanban, readGraph, resolveDefaultWorkflow, log }: WorkflowOrchestratorDeps) {
+    this.workflowEngine = workflowEngine;
+    this.loadKanban = loadKanban;
+    this.readGraph = readGraph;
+    this.resolveDefaultWorkflow = resolveDefaultWorkflow;
+    this.log = log;
+  }
+
+  startPlayAll = async (projectId: string, epicId?: string) => {
+    if (this.active) {
+      return { error: 'Play All is already running', status: 409 };
+    }
+
+    this.active = true;
+    this.aborted = false;
+    this.currentFeatureId = null;
+    this.projectId = projectId;
+    this.epicId = epicId || null;
+    this.processedCount = 0;
+    this.skippedFeatures = [];
+
+    const scope = epicId ? ` for epic ${epicId}` : '';
+    this.log('ORCHESTRATOR', `Play All started${projectId ? ` for project ${projectId}` : ''}${scope}`);
+
+    // Fire-and-forget — loop runs in the background
+    this.runLoop().catch(err => {
+      this.log('ORCHESTRATOR', `Play All UNCAUGHT ERROR: ${err.message}`);
+    }).finally(() => {
+      this.active = false;
+      this.currentFeatureId = null;
+      this.log('ORCHESTRATOR', `Play All ended. Processed ${this.processedCount} features.`);
+    });
+
+    return { started: true, status: 200 };
+  };
+
+  stopPlayAll = () => {
+    if (!this.active) {
+      return { error: 'Play All is not running', status: 400 };
+    }
+    this.aborted = true;
+    this.log('ORCHESTRATOR', 'Play All stop requested');
+    return { stopped: true, status: 200 };
+  };
+
+  getStatus = () => {
+    return {
+      active: this.active,
+      currentFeatureId: this.currentFeatureId,
+      projectId: this.projectId,
+      epicId: this.epicId,
+      processedCount: this.processedCount,
+      skippedFeatures: this.skippedFeatures,
+    };
+  };
+
+  private runLoop = async () => {
+    // Resolve default workflow once at the start
+    const defaultWorkflow = await this.resolveDefaultWorkflow(this.projectId);
+    if (!defaultWorkflow) {
+      this.log('ORCHESTRATOR', 'No default workflow found — cannot start Play All');
+      return;
+    }
+
+    while (!this.aborted) {
+      let kanbanData: any;
+      let graphData: any;
+      try {
+        kanbanData = await this.loadKanban(this.projectId);
+        graphData = await this.readGraph(this.projectId);
+      } catch (err: any) {
+        this.log('ORCHESTRATOR', `Failed to fetch data: ${err.message}`);
+        break;
+      }
+
+      // Build feature node lookup
+      const featureNodes = new Map<string, any>();
+      graphData.nodes
+        .filter((n: any) => n.type === 'feature')
+        .forEach((n: any) => featureNodes.set(n.id, n));
+
+      // When running for a specific epic, restrict to its contained features
+      if (this.epicId) {
+        const epicChildIds = new Set<string>(
+          (graphData.edges || [])
+            .filter((e: any) => e.from === this.epicId && e.relation === 'contains')
+            .map((e: any) => e.to),
+        );
+        for (const id of featureNodes.keys()) {
+          if (!epicChildIds.has(id)) featureNodes.delete(id);
+        }
+      }
+
+      // Get TODO cards that aren't dev_blocked, sorted by completeness (highest first)
+      const todoCards = Object.entries(kanbanData)
+        .filter(([id, entry]: [string, any]) =>
+          entry.column === 'todo' && featureNodes.has(id) && !entry.dev_blocked
+        )
+        .map(([id]: [string, any]) => ({
+          id,
+          completeness: featureNodes.get(id).completeness || 0,
+        }))
+        .sort((a, b) => b.completeness - a.completeness);
+
+      if (todoCards.length === 0) {
+        this.log('ORCHESTRATOR', 'No TODO cards remaining — stopping');
+        break;
+      }
+
+      // Try to find an unblocked card
+      let processed = false;
+      this.skippedFeatures = [];
+
+      for (const card of todoCards) {
+        if (this.aborted) return;
+
+        // Check dependency ordering
+        const deps = graphData.edges
+          .filter((e: any) => e.from === card.id && e.relation === 'depends_on')
+          .map((e: any) => e.to)
+          .filter((depId: string) => graphData.nodes.some((n: any) => n.id === depId && n.type === 'feature'));
+        const COMPLETED_COLUMNS = ['done', 'qa'];
+        const blocked = deps.some((depId: string) =>
+          !kanbanData[depId] || !COMPLETED_COLUMNS.includes(kanbanData[depId].column)
+        );
+
+        if (blocked) {
+          this.skippedFeatures.push(card.id);
+          continue;
+        }
+
+        // Start workflow for this card
+        this.currentFeatureId = card.id;
+        this.log('ORCHESTRATOR', `Starting workflow for ${card.id}`);
+
+        try {
+          await this.workflowEngine.start(card.id, defaultWorkflow.id, this.projectId);
+        } catch (err: any) {
+          this.log('ORCHESTRATOR', `Failed to start workflow for ${card.id}: ${err.message}`);
+          continue;
+        }
+
+        // Wait for workflow to reach a terminal status
+        await this.waitForWorkflowCompletion(card.id);
+
+        if (this.aborted) return;
+
+        this.processedCount++;
+        processed = true;
+        break; // Process one card per iteration, then re-fetch data
+      }
+
+      // Deadlock: a full pass with zero features processable
+      if (!processed) {
+        this.log('ORCHESTRATOR', `Deadlock detected — ${this.skippedFeatures.length} features blocked: ${this.skippedFeatures.join(', ')}`);
+        break;
+      }
+    }
+  };
+
+  private waitForWorkflowCompletion = async (featureId: string): Promise<void> => {
+    const TERMINAL_STATUSES = ['idle', 'completed', 'failed'];
+    const POLL_INTERVAL_MS = 5000;
+
+    while (!this.aborted) {
+      try {
+        const status = await this.workflowEngine.getStatus(featureId);
+        if (TERMINAL_STATUSES.includes(status.status as string)) {
+          this.log('ORCHESTRATOR', `Workflow for ${featureId} reached terminal status: ${status.status}`);
+          return;
+        }
+      } catch (err: any) {
+        this.log('ORCHESTRATOR', `Error polling status for ${featureId}: ${err.message}`);
+        return;
+      }
+
+      await new Promise(resolve => setTimeout(resolve, POLL_INTERVAL_MS));
+    }
+  };
+}

package/templates/assistkick-product-system/packages/shared/tools/add_node.test.ts

@@ -0,0 +1,43 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+/**
+ * Re-implement the featureType derivation logic from add_node.ts for testing.
+ * This is the same logic used in the add_node script — tested here
+ * to verify data transformation without requiring a database connection.
+ */
+const deriveFeatureType = (
+  nodeType: string,
+  projectType: string | null | undefined,
+): string | null => {
+  if (nodeType === 'feature' && projectType === 'video') {
+    return 'video';
+  }
+  return null;
+};
+
+describe('deriveFeatureType', () => {
+  it('returns "video" for feature nodes in video projects', () => {
+    assert.equal(deriveFeatureType('feature', 'video'), 'video');
+  });
+
+  it('returns null for feature nodes in software projects', () => {
+    assert.equal(deriveFeatureType('feature', 'software'), null);
+  });
+
+  it('returns null for non-feature nodes in video projects', () => {
+    assert.equal(deriveFeatureType('component', 'video'), null);
+    assert.equal(deriveFeatureType('decision', 'video'), null);
+    assert.equal(deriveFeatureType('epic', 'video'), null);
+  });
+
+  it('returns null when project type is null or undefined', () => {
+    assert.equal(deriveFeatureType('feature', null), null);
+    assert.equal(deriveFeatureType('feature', undefined), null);
+  });
+
+  it('returns null for non-feature nodes in software projects', () => {
+    assert.equal(deriveFeatureType('component', 'software'), null);
+    assert.equal(deriveFeatureType('decision', 'software'), null);
+  });
+});

package/templates/assistkick-product-system/packages/shared/tools/add_node.ts

@@ -8,9 +8,10 @@
 import { program } from 'commander';
 import chalk from 'chalk';
 import { randomBytes } from 'node:crypto';
+import { eq } from 'drizzle-orm';
 import { NODE_TYPES, VALID_FEATURE_KINDS } from '../lib/constants.js';
 import { getDb } from '../lib/db.js';
-import { nodes } from '../db/schema.js';
+import { nodes, projects } from '../db/schema.js';
 import { deriveMetadata, templateSections } from '../lib/markdown.js';
 import { assertValidType, assertUniqueName } from '../lib/validator.js';
 
@@ -68,8 +69,17 @@ const opts = program.opts();
       })
       .join('\n');
 
-    // Insert directly into DB
+    // Derive featureType from project type for feature nodes
     const db = getDb();
+    let featureType: string | null = null;
+    if (opts.type === 'feature' && opts.projectId) {
+      const [project] = await db.select({ type: projects.type }).from(projects).where(eq(projects.id, opts.projectId));
+      if (project?.type === 'video') {
+        featureType = 'video';
+      }
+    }
+
+    // Insert directly into DB
     await db.insert(nodes).values({
       id,
       type: opts.type,
@@ -79,6 +89,7 @@ const opts = program.opts();
       completeness: meta.completeness,
       openQuestionsCount: meta.open_questions_count,
       kind: opts.type === 'feature' ? opts.kind : null,
+      featureType,
       createdAt: now,
       updatedAt: now,
       body,

package/templates/assistkick-product-system/packages/shared/tools/get_kanban.ts

@@ -51,7 +51,7 @@ const opts = program.opts();
     const kindMap = {};
     for (const node of graph.nodes) {
       nameMap[node.id] = node.name;
-      if (node.type === 'feature') {
+      if (node.type === 'feature' || node.type === 'epic') {
         kindMap[node.id] = node.kind || 'new';
       }
     }

package/templates/assistkick-product-system/packages/shared/tools/migrate_epics.test.ts

@@ -0,0 +1,226 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+// Re-implement the pure functions from migrate_epics.ts for testing.
+// These are the same functions used in the migration script — tested here
+// to verify data transformation logic without requiring a database connection.
+
+const parseSections = (body: string): Record<string, string> => {
+  const sections: Record<string, string> = {};
+  const lines = body.split('\n');
+  let currentSection: string | null = null;
+  let currentLines: string[] = [];
+
+  for (const line of lines) {
+    const match = line.match(/^## (.+)$/);
+    if (match) {
+      if (currentSection !== null) {
+        sections[currentSection] = currentLines.join('\n').trim();
+      }
+      currentSection = match[1].trim();
+      currentLines = [];
+    } else if (currentSection !== null) {
+      currentLines.push(line);
+    }
+  }
+  if (currentSection !== null) {
+    sections[currentSection] = currentLines.join('\n').trim();
+  }
+
+  return sections;
+};
+
+const squishSections = (sections: Record<string, string>): string => {
+  const parts: string[] = [];
+
+  for (const [name, content] of Object.entries(sections)) {
+    if (name === 'Relations') continue;
+    if (!content.trim()) continue;
+    parts.push(`### ${name}`);
+    parts.push(content.trim());
+    parts.push('');
+  }
+
+  return parts.join('\n').trim();
+};
+
+const toEpicId = (featId: string): string => {
+  return featId.replace(/^feat_/, 'epic_');
+};
+
+const buildEpicBody = (featureBody: string): string => {
+  const sections = parseSections(featureBody);
+  const squished = squishSections(sections);
+  return `## Description\n${squished}\n\n## Scope\n`;
+};
+
+// ── Tests ──
+
+describe('toEpicId', () => {
+  it('converts feat_ prefix to epic_', () => {
+    assert.equal(toEpicId('feat_a20d3b2d'), 'epic_a20d3b2d');
+  });
+
+  it('preserves hex suffix exactly', () => {
+    assert.equal(toEpicId('feat_21ad113d'), 'epic_21ad113d');
+  });
+
+  it('does not alter IDs without feat_ prefix', () => {
+    assert.equal(toEpicId('comp_abc12345'), 'comp_abc12345');
+  });
+});
+
+describe('parseSections', () => {
+  it('parses multiple sections from markdown body', () => {
+    const body = '## Description\nSome description text\n\n## Acceptance Criteria\n- Criterion 1\n- Criterion 2\n\n## Open Questions\n';
+    const sections = parseSections(body);
+
+    assert.equal(sections['Description'], 'Some description text');
+    assert.equal(sections['Acceptance Criteria'], '- Criterion 1\n- Criterion 2');
+    assert.equal(sections['Open Questions'], '');
+  });
+
+  it('handles empty body', () => {
+    const sections = parseSections('');
+    assert.deepEqual(sections, {});
+  });
+
+  it('handles body with no sections', () => {
+    const sections = parseSections('Just some text without headers');
+    assert.deepEqual(sections, {});
+  });
+
+  it('preserves multiline content within a section', () => {
+    const body = '## Notes\nLine 1\nLine 2\nLine 3';
+    const sections = parseSections(body);
+    assert.equal(sections['Notes'], 'Line 1\nLine 2\nLine 3');
+  });
+});
+
+describe('squishSections', () => {
+  it('converts section headers to ### sub-headings', () => {
+    const sections = {
+      'Description': 'Some description',
+      'Acceptance Criteria': '- AC 1\n- AC 2',
+    };
+    const result = squishSections(sections);
+
+    assert.ok(result.includes('### Description'));
+    assert.ok(result.includes('Some description'));
+    assert.ok(result.includes('### Acceptance Criteria'));
+    assert.ok(result.includes('- AC 1\n- AC 2'));
+  });
+
+  it('skips empty sections', () => {
+    const sections = {
+      'Description': 'Some description',
+      'Open Questions': '',
+      'Notes': '',
+    };
+    const result = squishSections(sections);
+
+    assert.ok(result.includes('### Description'));
+    assert.ok(!result.includes('### Open Questions'));
+    assert.ok(!result.includes('### Notes'));
+  });
+
+  it('skips the Relations section', () => {
+    const sections = {
+      'Description': 'Some description',
+      'Relations': '- contains → feat_001',
+    };
+    const result = squishSections(sections);
+
+    assert.ok(result.includes('### Description'));
+    assert.ok(!result.includes('### Relations'));
+    assert.ok(!result.includes('feat_001'));
+  });
+
+  it('returns empty string when all sections are empty', () => {
+    const sections = {
+      'Open Questions': '',
+      'Notes': '',
+    };
+    const result = squishSections(sections);
+    assert.equal(result, '');
+  });
+});
+
+describe('buildEpicBody', () => {
+  it('creates epic body with Description and Scope sections', () => {
+    const featureBody = '## Description\nVideo generation system\n\n## Acceptance Criteria\n- AC 1\n- AC 2\n\n## Open Questions\n\n## Resolved Questions\n- [x] Question 1 → Answer 1\n\n## Notes\nSome notes here\n';
+
+    const epicBody = buildEpicBody(featureBody);
+
+    // Should start with ## Description
+    assert.ok(epicBody.startsWith('## Description\n'));
+    // Should end with ## Scope section
+    assert.ok(epicBody.includes('## Scope\n'));
+    // Should contain original Description as ### sub-heading
+    assert.ok(epicBody.includes('### Description'));
+    assert.ok(epicBody.includes('Video generation system'));
+    // Should contain Acceptance Criteria as ### sub-heading
+    assert.ok(epicBody.includes('### Acceptance Criteria'));
+    assert.ok(epicBody.includes('- AC 1'));
+    // Should skip empty Open Questions section
+    assert.ok(!epicBody.includes('### Open Questions'));
+    // Should include Resolved Questions
+    assert.ok(epicBody.includes('### Resolved Questions'));
+    // Should include Notes
+    assert.ok(epicBody.includes('### Notes'));
+    assert.ok(epicBody.includes('Some notes here'));
+  });
+
+  it('handles feature with only Description', () => {
+    const featureBody = '## Description\nJust a description\n';
+
+    const epicBody = buildEpicBody(featureBody);
+
+    assert.ok(epicBody.startsWith('## Description\n'));
+    assert.ok(epicBody.includes('### Description'));
+    assert.ok(epicBody.includes('Just a description'));
+    assert.ok(epicBody.includes('## Scope\n'));
+  });
+
+  it('handles feature with empty body', () => {
+    const epicBody = buildEpicBody('');
+
+    assert.equal(epicBody, '## Description\n\n\n## Scope\n');
+  });
+});
+
+describe('reviewMeta key transformation', () => {
+  const toMetaKey = (nodeId: string) => `kanban:${nodeId}`;
+
+  it('transforms feat_ meta key to epic_ meta key', () => {
+    const oldKey = toMetaKey('feat_a20d3b2d');
+    const newKey = toMetaKey(toEpicId('feat_a20d3b2d'));
+    assert.equal(oldKey, 'kanban:feat_a20d3b2d');
+    assert.equal(newKey, 'kanban:epic_a20d3b2d');
+  });
+
+  it('preserves key format after transformation', () => {
+    const newKey = toMetaKey(toEpicId('feat_21ad113d'));
+    assert.ok(newKey.startsWith('kanban:epic_'));
+  });
+});
+
+describe('TARGET_FEAT_IDS mapping', () => {
+  const targets = ['feat_a20d3b2d', 'feat_21ad113d', 'feat_e75c9f47', 'feat_c4d0e19b'];
+
+  it('maps all 4 target IDs to epic_ prefix', () => {
+    const mapped = targets.map(toEpicId);
+    assert.deepEqual(mapped, [
+      'epic_a20d3b2d',
+      'epic_21ad113d',
+      'epic_e75c9f47',
+      'epic_c4d0e19b',
+    ]);
+  });
+
+  it('produces unique epic IDs', () => {
+    const mapped = targets.map(toEpicId);
+    const unique = new Set(mapped);
+    assert.equal(unique.size, 4);
+  });
+});