@assistkick/create 1.6.0 → 1.8.0

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

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+
+/**
+ * migrate_epics — One-time migration that converts 4 existing epic-like feature nodes
+ * to the new epic node type.
+ *
+ * Target nodes: feat_a20d3b2d, feat_21ad113d, feat_e75c9f47, feat_c4d0e19b
+ *
+ * For each target node:
+ *   1. Changes type from 'feature' to 'epic'
+ *   2. Squishes all sections into a single Description + adds empty Scope
+ *   3. Regenerates ID from feat_ to epic_ prefix
+ *   4. Updates all edge references (fromId/toId) and kanban entries
+ *   5. Sets completeness to 1.0
+ *
+ * Usage:
+ *   npx tsx packages/shared/tools/migrate_epics.ts --project-id <id>
+ *   npx tsx packages/shared/tools/migrate_epics.ts --project-id <id> --dry-run
+ */
+
+import { program } from 'commander';
+import chalk from 'chalk';
+import { eq } from 'drizzle-orm';
+import { getDb, closeDb } from '../lib/db.js';
+import { nodes, edges, kanban, reviewMeta } from '../db/schema.js';
+
+program
+  .requiredOption('--project-id <id>', 'Project ID')
+  .option('--dry-run', 'Report what would be changed without writing to database')
+  .parse();
+
+const opts = program.opts();
+
+const TARGET_FEAT_IDS = [
+  'feat_a20d3b2d',
+  'feat_21ad113d',
+  'feat_e75c9f47',
+  'feat_c4d0e19b',
+];
+
+/**
+ * Parse a section-based markdown body into { sectionName: content }.
+ */
+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;
+};
+
+/**
+ * Squish all feature sections into a single Description for the epic body.
+ * Preserves original section headers as ### sub-headings within Description.
+ * Skips the Relations section (auto-generated, not part of the body content).
+ */
+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();
+};
+
+/**
+ * Convert a feat_ ID to an epic_ ID by replacing the prefix.
+ */
+const toEpicId = (featId: string): string => {
+  return featId.replace(/^feat_/, 'epic_');
+};
+
+/**
+ * Migrate a single feature node to an epic node.
+ */
+const migrateNode = async (
+  db: ReturnType<typeof getDb>,
+  featId: string,
+  dryRun: boolean,
+): Promise<{ oldId: string; newId: string; name: string }> => {
+  const epicId = toEpicId(featId);
+
+  // Read the existing node
+  const rows = await db.select().from(nodes).where(eq(nodes.id, featId));
+  const row = rows[0];
+  if (!row) {
+    throw new Error(`Node not found: ${featId}`);
+  }
+
+  // Parse existing body and squish into epic format
+  const sections = parseSections(row.body || '');
+  const squished = squishSections(sections);
+
+  const epicBody = `## Description\n${squished}\n\n## Scope\n`;
+
+  const now = new Date().toISOString();
+
+  if (!dryRun) {
+    // 1. Insert the new epic node
+    await db.insert(nodes).values({
+      id: epicId,
+      type: 'epic',
+      name: row.name,
+      status: 'defined',
+      priority: row.priority,
+      completeness: 1.0,
+      openQuestionsCount: 0,
+      kind: null,
+      createdAt: row.createdAt,
+      updatedAt: now,
+      body: epicBody,
+      projectId: row.projectId,
+    });
+
+    // 2. Update edges where this node is the source (fromId)
+    const fromEdges = await db.select().from(edges).where(eq(edges.fromId, featId));
+    // Delete all old edges originating from the feat ID
+    await db.delete(edges).where(eq(edges.fromId, featId));
+    // Re-insert with the new epic ID
+    for (const edge of fromEdges) {
+      await db.insert(edges).values({
+        fromId: epicId,
+        relation: edge.relation,
+        toId: edge.toId,
+        projectId: edge.projectId,
+      }).onConflictDoNothing();
+    }
+
+    // 3. Update edges where this node is the target (toId)
+    const toEdges = await db.select().from(edges).where(eq(edges.toId, featId));
+    // Delete all old edges pointing to the feat ID
+    await db.delete(edges).where(eq(edges.toId, featId));
+    // Re-insert with the new epic ID
+    for (const edge of toEdges) {
+      await db.insert(edges).values({
+        fromId: edge.fromId,
+        relation: edge.relation,
+        toId: epicId,
+        projectId: edge.projectId,
+      }).onConflictDoNothing();
+    }
+
+    // 4. Update kanban entry
+    const kanbanRows = await db.select().from(kanban).where(eq(kanban.nodeId, featId));
+    if (kanbanRows.length > 0) {
+      const entry = kanbanRows[0];
+      await db.delete(kanban).where(eq(kanban.nodeId, featId));
+      await db.insert(kanban).values({
+        nodeId: epicId,
+        columnName: entry.columnName,
+        position: entry.position,
+        projectId: entry.projectId,
+      });
+    }
+
+    // 5. Migrate reviewMeta (kanban metadata) to new ID
+    const oldMetaKey = `kanban:${featId}`;
+    const newMetaKey = `kanban:${epicId}`;
+    const metaRows = await db.select().from(reviewMeta).where(eq(reviewMeta.key, oldMetaKey));
+    if (metaRows.length > 0) {
+      await db.delete(reviewMeta).where(eq(reviewMeta.key, oldMetaKey));
+      await db.insert(reviewMeta).values({
+        key: newMetaKey,
+        value: metaRows[0].value,
+        projectId: metaRows[0].projectId,
+      });
+    }
+
+    // 6. Delete the old feature node
+    await db.delete(nodes).where(eq(nodes.id, featId));
+  }
+
+  return { oldId: featId, newId: epicId, name: row.name };
+};
+
+const main = async () => {
+  const dryRun = opts.dryRun || false;
+  const db = getDb();
+
+  if (dryRun) {
+    console.log(chalk.cyan('=== DRY RUN — no database writes will occur ===\n'));
+  }
+
+  console.log(chalk.bold('Migrating epic-like features to epic node type...\n'));
+
+  const results: { oldId: string; newId: string; name: string }[] = [];
+  const errors: { featId: string; error: string }[] = [];
+
+  for (const featId of TARGET_FEAT_IDS) {
+    try {
+      console.log(chalk.blue(`  Migrating ${featId}...`));
+      const result = await migrateNode(db, featId, dryRun);
+      results.push(result);
+      console.log(chalk.green(`    ✓ ${result.oldId} → ${result.newId} (${result.name})`));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      errors.push({ featId, error: message });
+      console.log(chalk.red(`    ✗ ${featId}: ${message}`));
+    }
+  }
+
+  // Summary
+  console.log(chalk.bold('\n=== Migration Summary ==='));
+  console.log(`  Migrated: ${results.length}`);
+  console.log(`  Errors:   ${errors.length}`);
+
+  for (const r of results) {
+    console.log(`    ${r.oldId} → ${r.newId} (${r.name})`);
+  }
+
+  if (errors.length > 0) {
+    console.log(chalk.red('\n  Errors:'));
+    for (const e of errors) {
+      console.log(chalk.red(`    ${e.featId}: ${e.error}`));
+    }
+  }
+
+  if (dryRun) {
+    console.log(chalk.cyan('\n=== DRY RUN complete — no changes were made ==='));
+  }
+
+  closeDb();
+};
+
+main().catch((err) => {
+  console.error(chalk.red(`Migration failed: ${err.message}`));
+  closeDb();
+  process.exit(1);
+});

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

@@ -109,9 +109,9 @@ const opts = program.opts();
     }
     await patchNode(id, patch);
 
-    // Auto-add feature to kanban when it reaches defined + 100% completeness
+    // Auto-add feature/epic to kanban when it reaches defined + 100% completeness
     const finalStatus = opts.setStatus || meta.status;
-    if (nodeMeta.type === 'feature' && finalStatus === 'defined' && meta.completeness >= 1) {
+    if ((nodeMeta.type === 'feature' || nodeMeta.type === 'epic') && finalStatus === 'defined' && meta.completeness >= 1) {
       const existing = await getKanbanEntry(id);
       if (!existing) {
         await saveKanbanEntry(id, { column: 'backlog', rejection_count: 0, notes: [] }, opts.projectId);

package/templates/assistkick-product-system/packages/shared/utils/hello_workflow.test.ts

@@ -0,0 +1,10 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { helloWorkflow } from './hello_workflow.js';
+
+describe('helloWorkflow', () => {
+  it('returns the expected greeting string', () => {
+    const result = helloWorkflow();
+    assert.equal(result, 'Hello from workflow!');
+  });
+});

package/templates/assistkick-product-system/packages/shared/utils/hello_workflow.ts

@@ -0,0 +1,6 @@
+/**
+ * Minimal smoke-test utility to validate the end-to-end workflow pipeline.
+ */
+export const helloWorkflow = (): string => {
+  return 'Hello from workflow!';
+};

package/templates/assistkick-product-system/packages/video/Root.tsx

@@ -0,0 +1,85 @@
+/** @jsxImportSource react */
+import { Composition, Folder } from "remotion";
+import "./style.css";
+
+/**
+ * Dynamically registers all compositions exported by files in compositions/.
+ * Each composition module should export:
+ *   - component: React.FC (the composition component)
+ *   - id: string (composition ID)
+ *   - durationInFrames: number (default duration)
+ *   - fps?: number (default 30)
+ *   - width?: number (default 1920)
+ *   - height?: number (default 1080)
+ *   - defaultProps?: Record<string, unknown>
+ *   - calculateMetadata?: CalculateMetadataFunction
+ *
+ * To add a new composition, create a file in compositions/ that exports
+ * these fields and import it in the registry below.
+ */
+
+// ── Composition registry ─────────────────────────────────────────────────────
+// Import composition modules here. Each entry becomes a Remotion composition.
+// Example:
+//   import * as MyVideo from "./compositions/my_video";
+//   const compositions = [MyVideo];
+
+export type CompositionEntry = {
+  id: string;
+  component: React.FC<Record<string, unknown>>;
+  durationInFrames: number;
+  fps?: number;
+  width?: number;
+  height?: number;
+  defaultProps?: Record<string, unknown>;
+  calculateMetadata?: unknown;
+  folder?: string;
+};
+
+export const compositions: CompositionEntry[] = [];
+
+// ── Root ─────────────────────────────────────────────────────────────────────
+
+export const RemotionRoot: React.FC = () => {
+  // Group compositions by folder
+  const folders = new Map<string | undefined, CompositionEntry[]>();
+  for (const entry of compositions) {
+    const key = entry.folder;
+    if (!folders.has(key)) folders.set(key, []);
+    folders.get(key)!.push(entry);
+  }
+
+  const renderComposition = (entry: CompositionEntry) => (
+    <Composition
+      key={entry.id}
+      id={entry.id}
+      component={entry.component}
+      durationInFrames={entry.durationInFrames}
+      fps={entry.fps ?? 30}
+      width={entry.width ?? 1920}
+      height={entry.height ?? 1080}
+      defaultProps={entry.defaultProps ?? {}}
+      calculateMetadata={
+        entry.calculateMetadata as
+          | React.ComponentProps<typeof Composition>["calculateMetadata"]
+          | undefined
+      }
+    />
+  );
+
+  return (
+    <>
+      {/* Ungrouped compositions */}
+      {(folders.get(undefined) ?? []).map(renderComposition)}
+
+      {/* Grouped into folders */}
+      {[...folders.entries()]
+        .filter(([key]) => key !== undefined)
+        .map(([folderName, entries]) => (
+          <Folder key={folderName} name={folderName!}>
+            {entries.map(renderComposition)}
+          </Folder>
+        ))}
+    </>
+  );
+};

package/templates/assistkick-product-system/packages/video/components/email_scene.tsx

@@ -0,0 +1,231 @@
+/** @jsxImportSource react */
+import {
+  AbsoluteFill,
+  useCurrentFrame,
+  useVideoConfig,
+  interpolate,
+  spring,
+} from "remotion";
+import { colors, fonts } from "./theme";
+
+type EmailSceneProps = {
+  stepNumber?: number;
+  partLabel?: string;
+  title?: string;
+  senderName?: string;
+  subject?: string;
+  emailLines?: string[];
+};
+
+export const EmailScene: React.FC<EmailSceneProps> = ({
+  stepNumber = 1,
+  partLabel = "Step",
+  title = "Email Received",
+  senderName = "System",
+  subject = "Welcome",
+  emailLines = [
+    "Welcome!",
+    "",
+    "Your account has been created.",
+    "",
+    "Getting Started:",
+    "1. Log in using your credentials",
+    "2. Update your profile",
+    "3. Explore the dashboard",
+  ],
+}) => {
+  const frame = useCurrentFrame();
+  const { fps } = useVideoConfig();
+
+  const envelopeSpring = spring({
+    frame,
+    fps,
+    config: { damping: 15, stiffness: 200 },
+  });
+
+  const envelopeScale = interpolate(envelopeSpring, [0, 1], [0.5, 1]);
+  const envelopeOpacity = interpolate(envelopeSpring, [0, 1], [0, 1]);
+
+  const emailBodyOpacity = interpolate(
+    frame,
+    [0.8 * fps, 1.2 * fps],
+    [0, 1],
+    {
+      extrapolateLeft: "clamp",
+      extrapolateRight: "clamp",
+    },
+  );
+
+  const emailBodyY = interpolate(frame, [0.8 * fps, 1.2 * fps], [20, 0], {
+    extrapolateLeft: "clamp",
+    extrapolateRight: "clamp",
+  });
+
+  const visibleLines = Math.floor(
+    interpolate(frame, [1 * fps, 4.5 * fps], [0, emailLines.length], {
+      extrapolateLeft: "clamp",
+      extrapolateRight: "clamp",
+    }),
+  );
+
+  return (
+    <AbsoluteFill
+      style={{
+        backgroundColor: colors.baseDark,
+        fontFamily: fonts.sans,
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+      }}
+    >
+      {/* Step badge */}
+      <div
+        style={{
+          position: "absolute",
+          top: 40,
+          left: 80,
+          display: "flex",
+          alignItems: "center",
+          gap: 16,
+          opacity: envelopeOpacity,
+        }}
+      >
+        <div
+          style={{
+            width: 48,
+            height: 48,
+            borderRadius: "50%",
+            backgroundColor: colors.accentSecondary,
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center",
+            color: "white",
+            fontSize: 24,
+            fontWeight: 700,
+          }}
+        >
+          {stepNumber}
+        </div>
+        <span
+          style={{
+            color: colors.accentSecondary,
+            fontSize: 18,
+            fontWeight: 600,
+            textTransform: "uppercase",
+            letterSpacing: 2,
+          }}
+        >
+          {partLabel}
+        </span>
+      </div>
+
+      {/* Title */}
+      <div
+        style={{
+          position: "absolute",
+          top: 110,
+          left: 80,
+          opacity: envelopeOpacity,
+        }}
+      >
+        <h1
+          style={{
+            color: "white",
+            fontSize: 44,
+            fontWeight: 700,
+            margin: 0,
+          }}
+        >
+          {title}
+        </h1>
+      </div>
+
+      {/* Email card */}
+      <div
+        style={{
+          position: "absolute",
+          top: 190,
+          left: 80,
+          right: 80,
+          bottom: 60,
+          opacity: emailBodyOpacity,
+          transform: `translateY(${emailBodyY}px)`,
+        }}
+      >
+        {/* Email header */}
+        <div
+          style={{
+            backgroundColor: "#2a2a4a",
+            borderRadius: "12px 12px 0 0",
+            padding: "16px 24px",
+            display: "flex",
+            alignItems: "center",
+            gap: 12,
+          }}
+        >
+          <div
+            style={{
+              width: 40,
+              height: 40,
+              borderRadius: "50%",
+              backgroundColor: colors.accentPrimary,
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              color: "white",
+              fontSize: 18,
+              fontWeight: 700,
+            }}
+          >
+            {senderName.charAt(0).toUpperCase()}
+          </div>
+          <div>
+            <div style={{ color: "white", fontSize: 16, fontWeight: 600 }}>
+              {senderName}
+            </div>
+            <div style={{ color: "rgba(255,255,255,0.5)", fontSize: 13 }}>
+              Subject: {subject}
+            </div>
+          </div>
+        </div>
+
+        {/* Email body */}
+        <div
+          style={{
+            backgroundColor: "#22223a",
+            borderRadius: "0 0 12px 12px",
+            padding: "24px 32px",
+            border: "1px solid rgba(255,255,255,0.08)",
+            borderTop: "none",
+          }}
+        >
+          {emailLines.slice(0, visibleLines).map((line, i) => (
+            <div
+              key={i}
+              style={{
+                color:
+                  line.includes(":") && !line.startsWith(" ")
+                    ? colors.accentSecondary
+                    : line.startsWith("Welcome") ||
+                        line.startsWith("Getting Started")
+                      ? "white"
+                      : "rgba(255,255,255,0.7)",
+                fontSize: line === "" ? 8 : 19,
+                fontWeight:
+                  line.startsWith("Welcome") ||
+                  line.startsWith("Getting Started")
+                    ? 700
+                    : 400,
+                fontFamily: line.includes("://") ? fonts.mono : fonts.sans,
+                lineHeight: line === "" ? 1 : 1.8,
+                minHeight: line === "" ? 12 : "auto",
+              }}
+            >
+              {line || "\u00A0"}
+            </div>
+          ))}
+        </div>
+      </div>
+    </AbsoluteFill>
+  );
+};