@assistkick/create 1.7.0 → 1.9.0

package/templates/assistkick-product-system/packages/backend/src/services/bundle_service.ts

@@ -0,0 +1,182 @@
+/**
+ * BundleService — manages the Remotion bundle for the video package.
+ *
+ * Responsibilities:
+ * - Build the Remotion bundle from the video package (via @remotion/bundler)
+ * - Track bundle status (ready, building, last built timestamp)
+ * - Scan the compositions directory for available compositions and metadata
+ * - Serve bundle path for static file serving
+ */
+
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { execFile } from 'node:child_process';
+
+interface BundleServiceDeps {
+  videoPackageDir: string;
+  bundleOutputDir: string;
+  log: (tag: string, ...args: any[]) => void;
+}
+
+export interface CompositionMeta {
+  id: string;
+  durationInFrames: number;
+  fps: number;
+  width: number;
+  height: number;
+  folder?: string;
+}
+
+export interface BundleStatus {
+  ready: boolean;
+  building: boolean;
+  bundlePath: string | null;
+  lastBuiltAt: string | null;
+  error: string | null;
+}
+
+export class BundleService {
+  private readonly videoPackageDir: string;
+  private readonly bundleOutputDir: string;
+  private readonly log: BundleServiceDeps['log'];
+  private building = false;
+  private lastBuiltAt: string | null = null;
+  private lastError: string | null = null;
+
+  constructor({ videoPackageDir, bundleOutputDir, log }: BundleServiceDeps) {
+    this.videoPackageDir = videoPackageDir;
+    this.bundleOutputDir = bundleOutputDir;
+    this.log = log;
+  }
+
+  /** Returns the directory path where the built bundle is stored. */
+  getBundleDir = (): string => {
+    return this.bundleOutputDir;
+  };
+
+  /** Check if a bundle has been built and exists on disk. */
+  isBundleReady = (): boolean => {
+    return existsSync(join(this.bundleOutputDir, 'index.html'));
+  };
+
+  /** Returns current bundle status. */
+  getStatus = (): BundleStatus => {
+    return {
+      ready: this.isBundleReady(),
+      building: this.building,
+      bundlePath: this.isBundleReady() ? this.bundleOutputDir : null,
+      lastBuiltAt: this.lastBuiltAt,
+      error: this.lastError,
+    };
+  };
+
+  /**
+   * Build the Remotion bundle from the video package.
+   * Uses the Remotion CLI to create a webpack bundle.
+   */
+  buildBundle = async (): Promise<BundleStatus> => {
+    if (this.building) {
+      this.log('BUNDLE', 'Bundle build already in progress');
+      return this.getStatus();
+    }
+
+    this.building = true;
+    this.lastError = null;
+    this.log('BUNDLE', `Building Remotion bundle from ${this.videoPackageDir}`);
+
+    try {
+      await this.spawnBundler();
+      this.lastBuiltAt = new Date().toISOString();
+      this.log('BUNDLE', `Bundle built successfully at ${this.lastBuiltAt}`);
+    } catch (err: any) {
+      this.lastError = err.message;
+      this.log('BUNDLE', `Bundle build failed: ${err.message}`);
+    } finally {
+      this.building = false;
+    }
+
+    return this.getStatus();
+  };
+
+  /**
+   * Scan the video package's compositions/ directory and extract metadata
+   * from each composition's index.tsx file.
+   */
+  listCompositions = (): CompositionMeta[] => {
+    const compositionsDir = join(this.videoPackageDir, 'compositions');
+    if (!existsSync(compositionsDir)) {
+      return [];
+    }
+
+    const entries = readdirSync(compositionsDir);
+    const compositions: CompositionMeta[] = [];
+
+    for (const entry of entries) {
+      const entryPath = join(compositionsDir, entry);
+      if (!statSync(entryPath).isDirectory()) continue;
+
+      const indexPath = join(entryPath, 'index.tsx');
+      if (!existsSync(indexPath)) continue;
+
+      const meta = this.parseCompositionMeta(indexPath);
+      if (meta) {
+        compositions.push(meta);
+      }
+    }
+
+    return compositions;
+  };
+
+  /**
+   * Parse a composition's index.tsx file to extract exported metadata.
+   * Uses regex to find exported const values for id, fps, width, height, etc.
+   */
+  private parseCompositionMeta = (filePath: string): CompositionMeta | null => {
+    try {
+      const content = readFileSync(filePath, 'utf-8');
+
+      const idMatch = content.match(/export\s+const\s+id\s*=\s*['"]([^'"]+)['"]/);
+      if (!idMatch) return null;
+
+      const durationMatch = content.match(/export\s+const\s+durationInFrames\s*=\s*(\d+)/);
+      const fpsMatch = content.match(/export\s+const\s+fps\s*=\s*(\d+)/);
+      const widthMatch = content.match(/export\s+const\s+width\s*=\s*(\d+)/);
+      const heightMatch = content.match(/export\s+const\s+height\s*=\s*(\d+)/);
+      const folderMatch = content.match(/export\s+const\s+folder\s*=\s*['"]([^'"]+)['"]/);
+
+      return {
+        id: idMatch[1],
+        durationInFrames: durationMatch ? parseInt(durationMatch[1], 10) : 300,
+        fps: fpsMatch ? parseInt(fpsMatch[1], 10) : 30,
+        width: widthMatch ? parseInt(widthMatch[1], 10) : 1920,
+        height: heightMatch ? parseInt(heightMatch[1], 10) : 1080,
+        folder: folderMatch ? folderMatch[1] : undefined,
+      };
+    } catch {
+      return null;
+    }
+  };
+
+  private spawnBundler = (): Promise<void> => {
+    return new Promise((resolve, reject) => {
+      const entryPoint = join(this.videoPackageDir, 'index.ts');
+      execFile('npx', [
+        'remotion', 'bundle',
+        entryPoint,
+        '--out-dir', this.bundleOutputDir,
+        '--log', 'warn',
+      ], {
+        cwd: this.videoPackageDir,
+        timeout: 300_000,
+        maxBuffer: 10 * 1024 * 1024,
+        env: { ...process.env },
+      }, (error, _stdout, stderr) => {
+        if (error) {
+          reject(new Error(`Remotion bundle failed: ${error.message}${stderr ? `\n${stderr}` : ''}`));
+          return;
+        }
+        resolve();
+      });
+    });
+  };
+}

package/templates/assistkick-product-system/packages/backend/src/services/init.ts

@@ -1,24 +1,25 @@
 /**
- * Service initialization — creates pipeline, claude service, and related instances.
+ * Service initialization — creates workflow engine, claude service, and related instances.
  * Deferred until VERBOSE flag is set at startup.
  */
 
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { existsSync } from 'node:fs';
 import { createClaudeService } from '@assistkick/shared/lib/claude-service.js';
-import { Pipeline } from '@assistkick/shared/lib/pipeline.js';
-import { PipelineStateStore } from '@assistkick/shared/lib/pipeline-state-store.js';
-import { PromptBuilder } from '@assistkick/shared/lib/prompt_builder.js';
 import { GitWorkflow } from '@assistkick/shared/lib/git_workflow.js';
 import { getDb } from '@assistkick/shared/lib/db.js';
 import { loadKanban, getKanbanEntry, saveKanbanEntry } from '@assistkick/shared/lib/kanban.js';
-import { readGraph, getNode } from '@assistkick/shared/lib/graph.js';
-import { WorkSummaryParser } from '@assistkick/shared/lib/work_summary_parser.js';
-import { PipelineOrchestrator } from '@assistkick/shared/lib/pipeline_orchestrator.js';
+import { readGraph } from '@assistkick/shared/lib/graph.js';
+import { WorkflowEngine } from '@assistkick/shared/lib/workflow_engine.js';
+import { WorkflowOrchestrator } from '@assistkick/shared/lib/workflow_orchestrator.js';
+import { WorkflowService } from './workflow_service.js';
+import { WorkflowGroupService } from './workflow_group_service.js';
 import { GitHubAppService } from './github_app_service.js';
 import { ProjectWorkspaceService } from './project_workspace_service.js';
-import { ProjectService } from './project_service.js';
+import { SshKeyService } from './ssh_key_service.js';
+import { BundleService } from './bundle_service.js';
+import { TtsService } from './tts_service.js';
+import { VideoRenderService } from './video_render_service.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // Navigate from packages/backend/src/services/ up to assistkick-product-system/
@@ -32,10 +33,13 @@ const TOOLS_DIR = IS_DEV ? join(SHARED_DIR, 'tools') : join(__dirname, '..', '..
 const DATA_DIR = SHARED_DIR;
 const PROJECT_ROOT = join(SKILL_ROOT, '..');
 const SKILLS_DIR = join(PROJECT_ROOT, '.claude', 'skills');
+const WORKSPACES_DIR = process.env.WORKSPACES_DIR || join(PROJECT_ROOT, 'workspaces');
 const WORKTREES_DIR = join(PROJECT_ROOT, '.worktrees');
 const DEVELOPER_SKILL_PATH = join(SKILLS_DIR, 'product-developer', 'SKILL.md');
 const REVIEWER_SKILL_PATH = join(SKILLS_DIR, 'product-code-reviewer', 'SKILL.md');
 const DEBUGGER_SKILL_PATH = join(SKILLS_DIR, 'product-debugger', 'SKILL.md');
+const VIDEO_PACKAGE_DIR = join(SKILL_ROOT, 'video');
+const BUNDLE_OUTPUT_DIR = process.env.REMOTION_BUNDLE_DIR || join(PROJECT_ROOT, 'data', 'remotion-bundle');
 
 export const log = (tag: string, ...args: any[]) => {
   const ts = new Date().toISOString().slice(11, 23);
@@ -43,14 +47,20 @@ export const log = (tag: string, ...args: any[]) => {
 };
 
 export let claudeService: any;
-export let pipeline: any;
-export let pipelineStateStore: any;
-export let orchestrator: PipelineOrchestrator;
+export let workflowEngine: WorkflowEngine;
+export let orchestrator: WorkflowOrchestrator;
+export let workflowService: WorkflowService;
+export let workflowGroupService: WorkflowGroupService;
 export let githubAppService: GitHubAppService;
+export let sshKeyService: SshKeyService;
 export let workspaceService: ProjectWorkspaceService;
+export let bundleService: BundleService;
+export let ttsService: TtsService;
+export let videoRenderService: VideoRenderService;
 
 export const paths = {
   projectRoot: PROJECT_ROOT,
+  workspacesDir: WORKSPACES_DIR,
   worktreesDir: WORKTREES_DIR,
   skillsDir: SKILLS_DIR,
   toolsDir: TOOLS_DIR,
@@ -64,84 +74,40 @@ export const paths = {
 
 export const initServices = (verbose: boolean) => {
   claudeService = createClaudeService({ verbose, log });
-  pipelineStateStore = new PipelineStateStore({ getDb });
-  const promptBuilder = new PromptBuilder({ paths, log });
   const gitWorkflow = new GitWorkflow({ claudeService, projectRoot: PROJECT_ROOT, worktreesDir: WORKTREES_DIR, log });
-  const workSummaryParser = new WorkSummaryParser();
 
   // New services for project git repo integration
   githubAppService = new GitHubAppService({ log });
-  workspaceService = new ProjectWorkspaceService({ claudeService, projectRoot: PROJECT_ROOT, log });
-  const projectService = new ProjectService({ getDb, log });
+  sshKeyService = new SshKeyService({ log });
+  workspaceService = new ProjectWorkspaceService({ claudeService, workspacesDir: WORKSPACES_DIR, log, sshKeyService });
 
-  /**
-   * Resolve a project-scoped workspace for the pipeline.
-   * Returns a GitWorkflow pointing to the project workspace + an afterMerge hook
-   * that pushes to the remote. Returns null if no workspace is configured.
-   */
-  const resolveProjectWorkspace = async (projectId: string) => {
-    const project = await projectService.getById(projectId);
-    if (!project) return null;
+  // Workflow service for CRUD + default resolution
+  workflowService = new WorkflowService({ getDb, log });
+  workflowGroupService = new WorkflowGroupService({ getDb, log });
 
-    // Check if project has a workspace
-    if (!workspaceService.hasWorkspace(projectId)) {
-      // No workspace — use default behavior
-      return null;
-    }
+  // Video services for workflow video node types
+  bundleService = new BundleService({ videoPackageDir: VIDEO_PACKAGE_DIR, bundleOutputDir: BUNDLE_OUTPUT_DIR, log });
+  ttsService = new TtsService({ workspacesDir: WORKSPACES_DIR, videoPackageDir: VIDEO_PACKAGE_DIR, log });
+  videoRenderService = new VideoRenderService({ getDb, workspacesDir: WORKSPACES_DIR, bundleOutputDir: BUNDLE_OUTPUT_DIR, log });
 
-    const wsPath = workspaceService.getWorkspacePath(projectId);
-    const wsWorktreesDir = workspaceService.getWorktreesDir(projectId);
-
-    const projectGitWorkflow = new GitWorkflow({
-      claudeService,
-      projectRoot: wsPath,
-      worktreesDir: wsWorktreesDir,
-      log,
-    });
-
-    // Build afterMerge hook for pushing to remote
-    let afterMerge = null;
-    if (project.repoUrl && project.githubInstallationId && project.githubRepoFullName) {
-      afterMerge = async () => {
-        // Get a fresh token for push
-        const token = await githubAppService.getInstallationToken(project.githubInstallationId!);
-        const authUrl = `https://x-access-token:${token}@github.com/${project.githubRepoFullName}.git`;
-        await projectGitWorkflow.setRemoteUrl(authUrl);
-        try {
-          const branch = project.baseBranch || 'main';
-          await projectGitWorkflow.pushToRemote(branch);
-        } finally {
-          // Reset to non-authenticated URL
-          await projectGitWorkflow.setRemoteUrl(`https://github.com/${project.githubRepoFullName}.git`).catch(() => {});
-        }
-      };
-    }
-
-    return { gitWorkflow: projectGitWorkflow, afterMerge };
-  };
-
-  pipeline = new Pipeline({
-    promptBuilder,
-    gitWorkflow,
-    claudeService,
+  // WorkflowEngine replaces Pipeline
+  workflowEngine = new WorkflowEngine({
+    db: getDb(),
     kanban: { getKanbanEntry, saveKanbanEntry },
-    paths,
+    claudeService,
+    gitWorkflow,
+    bundleService,
+    ttsService,
+    videoRenderService,
     log,
-    stateStore: pipelineStateStore,
-    workSummaryParser,
-    getNode,
-    resolveProjectWorkspace,
   });
 
-  orchestrator = new PipelineOrchestrator({
-    pipeline,
+  // WorkflowOrchestrator replaces PipelineOrchestrator
+  orchestrator = new WorkflowOrchestrator({
+    workflowEngine,
     loadKanban,
     readGraph,
+    resolveDefaultWorkflow: (projectId?: string) => workflowService.resolveDefault(projectId),
     log,
   });
-
-  // Mark any active pipeline states as interrupted (server restart recovery)
-  pipelineStateStore.markInterrupted().catch((err: any) => {
-    log('STARTUP', `Failed to mark interrupted pipelines: ${err.message}`);
-  });
 };

package/templates/assistkick-product-system/packages/backend/src/services/project_service.test.ts

@@ -118,12 +118,28 @@ describe('ProjectService', () => {
 
       assert.ok(result.id.startsWith('proj_'));
       assert.equal(result.name, 'New Project');
+      assert.equal(result.type, 'software');
       assert.equal(result.isDefault, 0);
       assert.equal(result.archivedAt, null);
       assert.ok(result.createdAt);
       assert.ok(result.updatedAt);
       assert.equal(db.insert.mock.calls.length, 1);
     });
+
+    it('creates a project with video type', async () => {
+      const result = await service.create('Video Project', 'video');
+
+      assert.ok(result.id.startsWith('proj_'));
+      assert.equal(result.name, 'Video Project');
+      assert.equal(result.type, 'video');
+      assert.equal(result.isDefault, 0);
+    });
+
+    it('defaults to software type when no type specified', async () => {
+      const result = await service.create('Default Type');
+
+      assert.equal(result.type, 'software');
+    });
   });
 
   describe('rename', () => {

package/templates/assistkick-product-system/packages/backend/src/services/project_service.ts

@@ -15,12 +15,16 @@ interface ProjectServiceDeps {
 export interface ProjectRecord {
   id: string;
   name: string;
+  type: string;
   isDefault: number;
   archivedAt: string | null;
   repoUrl: string | null;
   githubInstallationId: string | null;
   githubRepoFullName: string | null;
   baseBranch: string | null;
+  gitAuthMethod: string | null;
+  sshPrivateKeyEncrypted: string | null;
+  sshPublicKey: string | null;
   createdAt: string;
   updatedAt: string;
 }
@@ -58,7 +62,7 @@ export class ProjectService {
     return row || null;
   };
 
-  create = async (name: string): Promise<ProjectRecord> => {
+  create = async (name: string, type: string = 'software'): Promise<ProjectRecord> => {
     const db = this.getDb();
     const now = new Date().toISOString();
     const id = this.generateId();
@@ -66,18 +70,22 @@ export class ProjectService {
     const record: ProjectRecord = {
       id,
       name,
+      type,
       isDefault: 0,
       archivedAt: null,
       repoUrl: null,
       githubInstallationId: null,
       githubRepoFullName: null,
       baseBranch: null,
+      gitAuthMethod: null,
+      sshPrivateKeyEncrypted: null,
+      sshPublicKey: null,
       createdAt: now,
       updatedAt: now,
     };
 
     await db.insert(projects).values(record);
-    this.log('PROJECTS', `Created project: ${name} (${id})`);
+    this.log('PROJECTS', `Created project: ${name} (${id}) type=${type}`);
     return record;
   };
 
@@ -195,6 +203,9 @@ export class ProjectService {
         githubInstallationId: null,
         githubRepoFullName: null,
         baseBranch: null,
+        gitAuthMethod: null,
+        sshPrivateKeyEncrypted: null,
+        sshPublicKey: null,
         updatedAt: now,
       })
       .where(eq(projects.id, id));
@@ -206,6 +217,66 @@ export class ProjectService {
       githubInstallationId: null,
       githubRepoFullName: null,
       baseBranch: null,
+      gitAuthMethod: null,
+      sshPrivateKeyEncrypted: null,
+      sshPublicKey: null,
+      updatedAt: now,
+    };
+  };
+
+  /** Store SSH key data and set auth method to 'ssh_key'. */
+  setSshKeys = async (id: string, opts: {
+    sshPrivateKeyEncrypted: string;
+    sshPublicKey: string;
+  }): Promise<ProjectRecord> => {
+    const db = this.getDb();
+    const existing = await this.getById(id);
+    if (!existing) throw new Error('Project not found');
+
+    const now = new Date().toISOString();
+    await db
+      .update(projects)
+      .set({
+        gitAuthMethod: 'ssh_key',
+        sshPrivateKeyEncrypted: opts.sshPrivateKeyEncrypted,
+        sshPublicKey: opts.sshPublicKey,
+        updatedAt: now,
+      })
+      .where(eq(projects.id, id));
+
+    this.log('PROJECTS', `Set SSH keys for project ${id}`);
+    return {
+      ...existing,
+      gitAuthMethod: 'ssh_key',
+      sshPrivateKeyEncrypted: opts.sshPrivateKeyEncrypted,
+      sshPublicKey: opts.sshPublicKey,
+      updatedAt: now,
+    };
+  };
+
+  /** Set auth method to 'github_app' and clear SSH keys. */
+  setGitHubAppAuth = async (id: string): Promise<ProjectRecord> => {
+    const db = this.getDb();
+    const existing = await this.getById(id);
+    if (!existing) throw new Error('Project not found');
+
+    const now = new Date().toISOString();
+    await db
+      .update(projects)
+      .set({
+        gitAuthMethod: 'github_app',
+        sshPrivateKeyEncrypted: null,
+        sshPublicKey: null,
+        updatedAt: now,
+      })
+      .where(eq(projects.id, id));
+
+    this.log('PROJECTS', `Set GitHub App auth for project ${id}`);
+    return {
+      ...existing,
+      gitAuthMethod: 'github_app',
+      sshPrivateKeyEncrypted: null,
+      sshPublicKey: null,
       updatedAt: now,
     };
   };

package/templates/assistkick-product-system/packages/backend/src/services/project_workspace_service.test.ts

@@ -3,7 +3,7 @@ import assert from 'node:assert/strict';
 import { ProjectWorkspaceService } from './project_workspace_service.ts';
 import { join } from 'node:path';
 
-const PROJECT_ROOT = '/tmp/test-project-root';
+const WORKSPACES_DIR = '/tmp/test-workspaces';
 
 const createMockClaudeService = () => ({
   spawnCommand: mock.fn(async () => ''),
@@ -12,7 +12,7 @@ const createMockClaudeService = () => ({
 const createService = (claudeService: any) => {
   return new ProjectWorkspaceService({
     claudeService,
-    projectRoot: PROJECT_ROOT,
+    workspacesDir: WORKSPACES_DIR,
     log: mock.fn(),
   });
 };
@@ -29,14 +29,14 @@ describe('ProjectWorkspaceService', () => {
   describe('getWorkspacePath', () => {
     it('returns correct workspace path for a project', () => {
       const path = service.getWorkspacePath('proj_abc123');
-      assert.equal(path, join(PROJECT_ROOT, 'workspaces', 'proj_abc123'));
+      assert.equal(path, join(WORKSPACES_DIR, 'proj_abc123'));
     });
   });
 
   describe('getWorktreesDir', () => {
     it('returns correct worktrees dir inside workspace', () => {
       const path = service.getWorktreesDir('proj_abc123');
-      assert.equal(path, join(PROJECT_ROOT, 'workspaces', 'proj_abc123', '.worktrees'));
+      assert.equal(path, join(WORKSPACES_DIR, 'proj_abc123', '.worktrees'));
     });
   });