@assistkick/create 1.8.0 → 1.10.0

package/templates/assistkick-product-system/packages/shared/db/migrations/meta/_journal.json

@@ -99,6 +99,13 @@
       "when": 1773179139368,
       "tag": "0013_reflective_prowler",
       "breakpoints": true
+    },
+    {
+      "idx": 14,
+      "version": "6",
+      "when": 1773187819583,
+      "tag": "0014_nifty_punisher",
+      "breakpoints": true
     }
   ]
 }

package/templates/assistkick-product-system/packages/shared/db/schema.ts

@@ -188,6 +188,7 @@ export const workflows = sqliteTable('workflows', {
   description: text('description'),
   projectId: text('project_id'),
   featureType: text('feature_type'),
+  triggerColumn: text('trigger_column'),
   isDefault: integer('is_default').notNull().default(0),
   graphData: text('graph_data').notNull(),
   createdAt: text('created_at').notNull(),

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

@@ -205,7 +205,7 @@ export const emitAssistantUsage = (jsonStr, callback) => {
  * @returns {{ spawnClaude: function, spawnCommand: function }}
  */
 export const createClaudeService = ({ verbose = false, log: logFn }) => {
-  const spawnClaude = (prompt, cwd, label = 'claude', { onToolUse, onResult, onTurnUsage, onAssistantText } = {}) => new Promise((resolve, reject) => {
+  const spawnClaude = (prompt, cwd, label = 'claude', { onToolUse, onResult, onTurnUsage, onAssistantText } = {} as any) => new Promise((resolve, reject) => {
     const promptPreview = prompt.slice(0, 100).replace(/\n/g, '\\n');
     logFn('CLAUDE', `Spawning ${label} in ${cwd} — prompt length: ${prompt.length} chars`);
     logFn('CLAUDE', `Prompt preview: "${promptPreview}..."`);

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

@@ -1,6 +1,6 @@
 import { describe, it, mock, beforeEach } from 'node:test';
 import assert from 'node:assert/strict';
-import { WorkflowEngine } from './workflow_engine.ts';
+import {WorkflowEngine} from "./workflow_engine.js";
 
 // ── Default workflow graph (matches seeded data) ──────────────────────
 
@@ -1750,4 +1750,250 @@ describe('WorkflowEngine', () => {
       assert.deepEqual(nodeExecs['transition_1'].toolCalls, []);
     });
   });
+
+  // ── Video Workflow Node Type Tests ────────────────────────────────
+
+  describe('handleRebuildBundle', () => {
+    it('calls bundleService.buildBundle and returns success', async () => {
+      const mockBundleService = {
+        buildBundle: mock.fn(async () => ({
+          ready: true,
+          building: false,
+          bundlePath: '/tmp/bundle',
+          lastBuiltAt: '2026-03-11T00:00:00.000Z',
+          error: null,
+        })),
+      };
+
+      const engine = new WorkflowEngine({
+        db: createMockDb() as any,
+        kanban: createMockKanban(),
+        claudeService: createMockClaudeService(),
+        gitWorkflow: createMockGitWorkflow(),
+        bundleService: mockBundleService,
+        log: createMockLog(),
+      });
+
+      const node = { id: 'rebuild', type: 'rebuildBundle', data: {} };
+      const result = await (engine as any).handleRebuildBundle(node, defaultContext());
+
+      assert.equal(result.outputLabel, null);
+      assert.equal(result.outputData.ready, true);
+      assert.equal(result.outputData.bundlePath, '/tmp/bundle');
+      assert.equal(mockBundleService.buildBundle.mock.callCount(), 1);
+    });
+
+    it('throws when bundle build fails', async () => {
+      const mockBundleService = {
+        buildBundle: mock.fn(async () => ({
+          ready: false,
+          building: false,
+          bundlePath: null,
+          error: 'webpack error',
+        })),
+      };
+
+      const engine = new WorkflowEngine({
+        db: createMockDb() as any,
+        kanban: createMockKanban(),
+        claudeService: createMockClaudeService(),
+        gitWorkflow: createMockGitWorkflow(),
+        bundleService: mockBundleService,
+        log: createMockLog(),
+      });
+
+      const node = { id: 'rebuild', type: 'rebuildBundle', data: {} };
+      await assert.rejects(
+        () => (engine as any).handleRebuildBundle(node, defaultContext()),
+        { message: 'Bundle build failed: webpack error' },
+      );
+    });
+
+    it('throws when bundleService is not configured', async () => {
+      const engine = new WorkflowEngine({
+        db: createMockDb() as any,
+        kanban: createMockKanban(),
+        claudeService: createMockClaudeService(),
+        gitWorkflow: createMockGitWorkflow(),
+        log: createMockLog(),
+      });
+
+      const node = { id: 'rebuild', type: 'rebuildBundle', data: {} };
+      await assert.rejects(
+        () => (engine as any).handleRebuildBundle(node, defaultContext()),
+        { message: /BundleService not configured/ },
+      );
+    });
+  });
+
+  describe('handleGenerateTTS', () => {
+    it('calls ttsService.generate with resolved script path', async () => {
+      const mockTtsService = {
+        generate: mock.fn(async () => ({
+          processed: 5,
+          generated: 3,
+          skipped: 2,
+          errors: [],
+          durations: { scene1: 5.2, scene2: 3.1 },
+          audioBasePath: '/tmp/audio',
+        })),
+      };
+
+      const engine = new WorkflowEngine({
+        db: createMockDb() as any,
+        kanban: createMockKanban(),
+        claudeService: createMockClaudeService(),
+        gitWorkflow: createMockGitWorkflow(),
+        ttsService: mockTtsService,
+        log: createMockLog(),
+      });
+
+      const node = {
+        id: 'tts',
+        type: 'generateTTS',
+        data: { scriptPath: 'script.md', force: true },
+      };
+      const ctx = defaultContext({ worktreePath: '/tmp/wt', projectId: 'proj_1' });
+      const result = await (engine as any).handleGenerateTTS(node, ctx);
+
+      assert.equal(result.outputLabel, null);
+      assert.equal(result.outputData.generated, 3);
+      assert.equal(result.outputData.skipped, 2);
+      assert.equal(result.outputData.audioBasePath, '/tmp/audio');
+      assert.equal(mockTtsService.generate.mock.callCount(), 1);
+
+      const callArgs = mockTtsService.generate.mock.calls[0].arguments[0];
+      assert.ok(callArgs.scriptPath.includes('script.md'));
+      assert.equal(callArgs.force, true);
+      assert.equal(callArgs.projectId, 'proj_1');
+      assert.equal(callArgs.featureId, 'feat_test');
+    });
+
+    it('throws when ttsService is not configured', async () => {
+      const engine = new WorkflowEngine({
+        db: createMockDb() as any,
+        kanban: createMockKanban(),
+        claudeService: createMockClaudeService(),
+        gitWorkflow: createMockGitWorkflow(),
+        log: createMockLog(),
+      });
+
+      const node = { id: 'tts', type: 'generateTTS', data: {} };
+      await assert.rejects(
+        () => (engine as any).handleGenerateTTS(node, defaultContext()),
+        { message: /TtsService not configured/ },
+      );
+    });
+  });
+
+  describe('handleRenderVideo', () => {
+    it('calls videoRenderService.startRender with node config', async () => {
+      const mockVideoRenderService = {
+        startRender: mock.fn(async () => ({
+          id: 'render-123',
+          status: 'queued',
+          progress: 0,
+          filePath: null,
+          error: null,
+          compositionId: 'my-comp',
+        })),
+      };
+
+      const engine = new WorkflowEngine({
+        db: createMockDb() as any,
+        kanban: createMockKanban(),
+        claudeService: createMockClaudeService(),
+        gitWorkflow: createMockGitWorkflow(),
+        videoRenderService: mockVideoRenderService,
+        log: createMockLog(),
+      });
+
+      const node = {
+        id: 'render',
+        type: 'renderVideo',
+        data: { compositionId: 'my-comp', resolution: '1280x720', fileOutputPrefix: 'output' },
+      };
+      const ctx = defaultContext({ projectId: 'proj_1' });
+      const result = await (engine as any).handleRenderVideo(node, ctx);
+
+      assert.equal(result.outputLabel, null);
+      assert.equal(result.outputData.renderId, 'render-123');
+      assert.equal(result.outputData.status, 'queued');
+      assert.equal(result.outputData.compositionId, 'my-comp');
+      assert.equal(mockVideoRenderService.startRender.mock.callCount(), 1);
+
+      const callArgs = mockVideoRenderService.startRender.mock.calls[0].arguments[0];
+      assert.equal(callArgs.compositionId, 'my-comp');
+      assert.equal(callArgs.resolution, '1280x720');
+      assert.equal(callArgs.fileOutputPrefix, 'output');
+    });
+
+    it('falls back to compositionName from context when compositionId is empty', async () => {
+      const mockVideoRenderService = {
+        startRender: mock.fn(async () => ({
+          id: 'render-456',
+          status: 'queued',
+          progress: 0,
+          filePath: null,
+          error: null,
+          compositionId: 'my-feature',
+        })),
+      };
+
+      const engine = new WorkflowEngine({
+        db: createMockDb() as any,
+        kanban: createMockKanban(),
+        claudeService: createMockClaudeService(),
+        gitWorkflow: createMockGitWorkflow(),
+        videoRenderService: mockVideoRenderService,
+        log: createMockLog(),
+      });
+
+      const node = { id: 'render', type: 'renderVideo', data: {} };
+      const ctx = defaultContext({ projectId: 'proj_1', compositionName: 'my-feature' });
+      const result = await (engine as any).handleRenderVideo(node, ctx);
+
+      assert.equal(result.outputData.compositionId, 'my-feature');
+      const callArgs = mockVideoRenderService.startRender.mock.calls[0].arguments[0];
+      assert.equal(callArgs.compositionId, 'my-feature');
+    });
+
+    it('throws when videoRenderService is not configured', async () => {
+      const engine = new WorkflowEngine({
+        db: createMockDb() as any,
+        kanban: createMockKanban(),
+        claudeService: createMockClaudeService(),
+        gitWorkflow: createMockGitWorkflow(),
+        log: createMockLog(),
+      });
+
+      const node = { id: 'render', type: 'renderVideo', data: {} };
+      await assert.rejects(
+        () => (engine as any).handleRenderVideo(node, defaultContext()),
+        { message: /VideoRenderService not configured/ },
+      );
+    });
+
+    it('throws when no compositionId is available', async () => {
+      const mockVideoRenderService = {
+        startRender: mock.fn(async () => ({})),
+      };
+
+      const engine = new WorkflowEngine({
+        db: createMockDb() as any,
+        kanban: createMockKanban(),
+        claudeService: createMockClaudeService(),
+        gitWorkflow: createMockGitWorkflow(),
+        videoRenderService: mockVideoRenderService,
+        log: createMockLog(),
+      });
+
+      const node = { id: 'render', type: 'renderVideo', data: {} };
+      const ctx = defaultContext({ projectId: 'proj_1' });
+      await assert.rejects(
+        () => (engine as any).handleRenderVideo(node, ctx),
+        { message: /No compositionId configured/ },
+      );
+    });
+  });
 });

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

@@ -63,6 +63,22 @@ interface NodeHandlerResult {
   outputData?: Record<string, unknown>;
 }
 
+interface BundleServiceDep {
+  buildBundle: () => Promise<{ ready: boolean; building: boolean; bundlePath: string | null; error: string | null }>;
+}
+
+interface TtsServiceDep {
+  generate: (opts: { scriptPath: string; projectId: string; featureId: string; force?: boolean; voiceId?: string }) => Promise<{
+    processed: number; generated: number; skipped: number; errors: string[]; durations: Record<string, number>; audioBasePath: string;
+  }>;
+}
+
+interface VideoRenderServiceDep {
+  startRender: (request: {
+    compositionId: string; projectId: string; featureId: string; resolution?: string; aspectRatio?: string; fileOutputPrefix?: string;
+  }) => Promise<{ id: string; status: string; progress: number; filePath: string | null; error: string | null; compositionId: string }>;
+}
+
 interface WorkflowEngineDeps {
   db: ReturnType<typeof import('./db.js').getDb>;
   kanban: {
@@ -85,6 +101,9 @@ interface WorkflowEngineDeps {
     unstash: () => Promise<void>;
     getDirtyFiles: () => Promise<string[]>;
   };
+  bundleService?: BundleServiceDep;
+  ttsService?: TtsServiceDep;
+  videoRenderService?: VideoRenderServiceDep;
   log: (tag: string, message: string) => void;
 }
 
@@ -95,13 +114,19 @@ export class WorkflowEngine {
   private kanban: WorkflowEngineDeps['kanban'];
   private claudeService: WorkflowEngineDeps['claudeService'];
   private gitWorkflow: WorkflowEngineDeps['gitWorkflow'];
+  private bundleService?: BundleServiceDep;
+  private ttsService?: TtsServiceDep;
+  private videoRenderService?: VideoRenderServiceDep;
   private log: WorkflowEngineDeps['log'];
 
-  constructor({ db, kanban, claudeService, gitWorkflow, log }: WorkflowEngineDeps) {
+  constructor({ db, kanban, claudeService, gitWorkflow, bundleService, ttsService, videoRenderService, log }: WorkflowEngineDeps) {
     this.db = db;
     this.kanban = kanban;
     this.claudeService = claudeService;
     this.gitWorkflow = gitWorkflow;
+    this.bundleService = bundleService;
+    this.ttsService = ttsService;
+    this.videoRenderService = videoRenderService;
     this.log = log;
   }
 
@@ -159,7 +184,7 @@ export class WorkflowEngine {
     // Load iteration comments from kanban notes for re-runs
     const kanbanEntry = await this.kanban.getKanbanEntry(featureId);
     if (kanbanEntry?.notes?.length) {
-      context.iterationComments = '## Previous Review Notes\n' + (kanbanEntry.notes as string[]).map((n: string) => `- ${n}`).join('\n');
+      context.iterationComments = '## Previous Review Notes\n' + (kanbanEntry.notes as Array<{ text?: string }>).map((n) => `- ${typeof n === 'string' ? n : (n.text || '')}`).join('\n');
     } else {
       context.iterationComments = '';
     }
@@ -598,6 +623,12 @@ export class WorkflowEngine {
         return this.handleEnd(node, context, executionId);
       case 'group':
         return this.handleGroup(node, context, executionId);
+      case 'rebuildBundle':
+        return this.handleRebuildBundle(node, context);
+      case 'generateTTS':
+        return this.handleGenerateTTS(node, context);
+      case 'renderVideo':
+        return this.handleRenderVideo(node, context);
       default:
         throw new Error(`Unknown node type: ${node.type}`);
     }
@@ -919,6 +950,131 @@ export class WorkflowEngine {
     return { outputLabel: null };
   };
 
+  /**
+   * RebuildBundle — triggers BundleService to compile the Remotion webpack bundle.
+   */
+  private handleRebuildBundle = async (
+    _node: WorkflowNode,
+    _context: ExecutionContext,
+  ): Promise<NodeHandlerResult> => {
+    if (!this.bundleService) {
+      throw new Error('BundleService not configured — cannot execute rebuildBundle node');
+    }
+
+    this.log('WORKFLOW', 'Building Remotion bundle...');
+    const result = await this.bundleService.buildBundle();
+
+    if (!result.ready) {
+      throw new Error(`Bundle build failed: ${result.error || 'unknown error'}`);
+    }
+
+    this.log('WORKFLOW', `Bundle built successfully at ${result.bundlePath}`);
+    return {
+      outputLabel: null,
+      outputData: { bundlePath: result.bundlePath, ready: result.ready },
+    };
+  };
+
+  /**
+   * GenerateTTS — runs TtsService to generate audio from a video script.
+   * Resolves scriptPath relative to the feature's worktree.
+   */
+  private handleGenerateTTS = async (
+    node: WorkflowNode,
+    context: ExecutionContext,
+  ): Promise<NodeHandlerResult> => {
+    if (!this.ttsService) {
+      throw new Error('TtsService not configured — cannot execute generateTTS node');
+    }
+
+    const { scriptPath, force, voiceId } = node.data as {
+      scriptPath?: string;
+      force?: boolean;
+      voiceId?: string;
+    };
+    const { featureId, projectId, worktreePath } = context;
+
+    // Resolve script path relative to worktree
+    const resolvedScriptPath = scriptPath
+      ? pathResolve(worktreePath as string, scriptPath)
+      : pathResolve(worktreePath as string, 'script.md');
+
+    this.log('WORKFLOW', `Generating TTS for feature=${featureId} script=${resolvedScriptPath}`);
+
+    const result = await this.ttsService.generate({
+      scriptPath: resolvedScriptPath,
+      projectId: projectId as string,
+      featureId: featureId as string,
+      force: force || false,
+      voiceId: voiceId || undefined,
+    });
+
+    if (result.errors.length > 0) {
+      this.log('WORKFLOW', `TTS completed with errors: ${result.errors.join(', ')}`);
+    }
+
+    this.log('WORKFLOW', `TTS complete: ${result.generated} generated, ${result.skipped} skipped`);
+    return {
+      outputLabel: null,
+      outputData: {
+        processed: result.processed,
+        generated: result.generated,
+        skipped: result.skipped,
+        errors: result.errors,
+        audioBasePath: result.audioBasePath,
+      },
+    };
+  };
+
+  /**
+   * RenderVideo — triggers VideoRenderService to render a composition to MP4.
+   * Waits for the render to complete by polling status.
+   */
+  private handleRenderVideo = async (
+    node: WorkflowNode,
+    context: ExecutionContext,
+  ): Promise<NodeHandlerResult> => {
+    if (!this.videoRenderService) {
+      throw new Error('VideoRenderService not configured — cannot execute renderVideo node');
+    }
+
+    const { compositionId, resolution, aspectRatio, fileOutputPrefix } = node.data as {
+      compositionId?: string;
+      resolution?: string;
+      aspectRatio?: string;
+      fileOutputPrefix?: string;
+    };
+    const { featureId, projectId, compositionName } = context;
+
+    // Use compositionId from node data, or fall back to context compositionName
+    const resolvedCompositionId = compositionId || (compositionName as string) || '';
+    if (!resolvedCompositionId) {
+      throw new Error('No compositionId configured on renderVideo node and no compositionName in context');
+    }
+
+    this.log('WORKFLOW', `Starting render: composition=${resolvedCompositionId} resolution=${resolution || '1920x1080'}`);
+
+    const renderStatus = await this.videoRenderService.startRender({
+      compositionId: resolvedCompositionId,
+      projectId: projectId as string,
+      featureId: featureId as string,
+      resolution,
+      aspectRatio,
+      fileOutputPrefix,
+    });
+
+    this.log('WORKFLOW', `Render started: id=${renderStatus.id} status=${renderStatus.status}`);
+    return {
+      outputLabel: null,
+      outputData: {
+        renderId: renderStatus.id,
+        status: renderStatus.status,
+        compositionId: resolvedCompositionId,
+        filePath: renderStatus.filePath,
+      },
+    };
+  };
+
   // ── Merge & Cleanup Helpers ─────────────────────────────────────────
 
   /**

package/templates/assistkick-product-system/tests/video_render_service.test.ts

@@ -19,6 +19,7 @@ describe('VideoRenderService', () => {
   let routeContent: string;
   let schemaContent: string;
   let serverContent: string;
+  let initContent: string;
   let dockerfileContent: string;
 
   it('loads source files', async () => {
@@ -26,6 +27,7 @@ describe('VideoRenderService', () => {
     routeContent = await readFile(join(BACKEND_SRC, 'routes', 'video.ts'), 'utf-8');
     schemaContent = await readFile(join(SHARED_DB, 'schema.ts'), 'utf-8');
     serverContent = await readFile(join(BACKEND_SRC, 'server.ts'), 'utf-8');
+    initContent = await readFile(join(BACKEND_SRC, 'services', 'init.ts'), 'utf-8');
     dockerfileContent = await readFile(join(SOURCE_ROOT, '..', 'Dockerfile'), 'utf-8');
     assert.ok(serviceContent.length > 0);
     assert.ok(routeContent.length > 0);
@@ -127,12 +129,12 @@ describe('VideoRenderService', () => {
   });
 
   describe('Server integration', () => {
-    it('imports VideoRenderService', () => {
-      assert.ok(serverContent.includes("import { VideoRenderService }"), 'server should import VideoRenderService');
+    it('imports VideoRenderService in init.ts', () => {
+      assert.ok(initContent.includes("import { VideoRenderService }"), 'init.ts should import VideoRenderService');
     });
 
-    it('instantiates VideoRenderService with DI', () => {
-      assert.ok(serverContent.includes('new VideoRenderService('), 'server should instantiate VideoRenderService');
+    it('instantiates VideoRenderService with DI in init.ts', () => {
+      assert.ok(initContent.includes('new VideoRenderService('), 'init.ts should instantiate VideoRenderService');
     });
 
     it('passes videoRenderService to video routes', () => {