@assistkick/create 1.0.0

package/templates/product-system/packages/shared/lib/kanban.ts

@@ -0,0 +1,161 @@
+/**
+ * Kanban board operations backed by Drizzle/Turso.
+ * Replaces direct kanban.json file I/O in tools.
+ */
+
+import {eq, sql} from 'drizzle-orm';
+import {getDb} from './db.js';
+/**
+ * Load the full kanban state as an object keyed by feature ID.
+ * Returns the same shape as the old kanban.json:
+ * { feat_001: { column, rejection_count, notes, dev_blocked?, moved_at } }
+ *
+ * Note: rejection_count, notes, dev_blocked, and moved_at are stored as JSON
+ * in a notes-like approach. Since the kanban table schema only has nodeId,
+ * columnName, and position, we store extra metadata in the node's body or
+ * a separate mechanism. For simplicity, we store extended kanban metadata
+ * as a JSON string in the position field's companion — actually we need
+ * to handle this differently.
+ *
+ * The kanban table has: nodeId, columnName, position.
+ * The old kanban.json had: column, rejection_count, notes[], dev_blocked, moved_at.
+ *
+ * We'll store the extra metadata (rejection_count, notes, dev_blocked, moved_at)
+ * as a JSON blob in a convention: we use the review_meta table with key pattern
+ * "kanban:{nodeId}" to store the extra data.
+ */
+import {kanban, nodes, reviewMeta} from '../db/schema.js';
+
+const kanbanMetaKey = (nodeId) => `kanban:${nodeId}`;
+
+const getKanbanMeta = async (db, nodeId) => {
+  const rows = await db.select().from(reviewMeta)
+    .where(eq(reviewMeta.key, kanbanMetaKey(nodeId)));
+  if (!rows[0]) return { rejection_count: 0, notes: [], reviews: [] };
+  return JSON.parse(rows[0].value);
+};
+
+const setKanbanMeta = async (db, nodeId, meta) => {
+  const key = kanbanMetaKey(nodeId);
+  const value = JSON.stringify(meta);
+  const existing = await db.select().from(reviewMeta).where(eq(reviewMeta.key, key));
+  if (existing[0]) {
+    await db.update(reviewMeta).set({ value }).where(eq(reviewMeta.key, key));
+  } else {
+    await db.insert(reviewMeta).values({ key, value });
+  }
+};
+
+/**
+ * Load the full kanban board state.
+ * Returns an object matching the old kanban.json shape.
+ */
+export const loadKanban = async (projectId?: string) => {
+  const db = getDb();
+
+  let rows;
+  if (projectId) {
+    // Join kanban with nodes to filter by project_id
+    rows = await db.select({nodeId: kanban.nodeId, columnName: kanban.columnName, position: kanban.position})
+        .from(kanban)
+        .innerJoin(nodes, eq(kanban.nodeId, nodes.id))
+        .where(eq(nodes.projectId, projectId));
+  } else {
+    rows = await db.select().from(kanban);
+  }
+
+  const allMeta = await db.select().from(reviewMeta).where(sql`key LIKE 'kanban:%'`);
+
+  // Build a lookup map from reviewMeta rows
+  const metaMap = new Map();
+  for (const m of allMeta) {
+    const nodeId = m.key.slice('kanban:'.length);
+    metaMap.set(nodeId, JSON.parse(m.value));
+  }
+
+  const result = {};
+  for (const row of rows) {
+    const meta = metaMap.get(row.nodeId) || { rejection_count: 0, notes: [], reviews: [] };
+    result[row.nodeId] = {
+      column: row.columnName,
+      rejection_count: meta.rejection_count || 0,
+      notes: meta.notes || [],
+      reviews: meta.reviews || [],
+      ...(meta.dev_blocked ? { dev_blocked: true } : {}),
+      ...(meta.moved_at ? { moved_at: meta.moved_at } : {}),
+    };
+  }
+
+  return result;
+};
+
+/**
+ * Check if the kanban board has any entries.
+ */
+export const kanbanExists = async (projectId?: string) => {
+  const db = getDb();
+  if (projectId) {
+    const rows = await db.select({ nodeId: kanban.nodeId })
+      .from(kanban)
+      .innerJoin(nodes, eq(kanban.nodeId, nodes.id))
+      .where(eq(nodes.projectId, projectId))
+      .limit(1);
+    return !!rows[0];
+  }
+  const rows = await db.select({ nodeId: kanban.nodeId }).from(kanban).limit(1);
+  return !!rows[0];
+};
+
+/**
+ * Get a single kanban entry by feature ID.
+ */
+export const getKanbanEntry = async (featureId) => {
+  const db = getDb();
+  const rows = await db.select().from(kanban).where(eq(kanban.nodeId, featureId));
+  if (!rows[0]) return null;
+
+  const meta = await getKanbanMeta(db, featureId);
+  return {
+    column: rows[0].columnName,
+    rejection_count: meta.rejection_count || 0,
+    notes: meta.notes || [],
+    reviews: meta.reviews || [],
+    ...(meta.dev_blocked ? { dev_blocked: true } : {}),
+    ...(meta.moved_at ? { moved_at: meta.moved_at } : {}),
+  };
+};
+
+/**
+ * Save a full kanban entry for a feature.
+ */
+export const saveKanbanEntry = async (featureId, entry, projectId?: string) => {
+  const db = getDb();
+
+  const existing = await db.select().from(kanban).where(eq(kanban.nodeId, featureId));
+  if (existing[0]) {
+    await db.update(kanban).set({
+      columnName: entry.column,
+    }).where(eq(kanban.nodeId, featureId));
+  } else {
+    // Determine position (append to end of column)
+    const colEntries = await db.select().from(kanban)
+      .where(eq(kanban.columnName, entry.column));
+    const maxPos = colEntries.reduce((max, r) => Math.max(max, r.position), -1);
+
+    await db.insert(kanban).values({
+      nodeId: featureId,
+      columnName: entry.column,
+      position: maxPos + 1,
+      projectId: projectId || null,
+    });
+  }
+
+  // Store extra metadata
+  await setKanbanMeta(db, featureId, {
+    rejection_count: entry.rejection_count || 0,
+    notes: entry.notes || [],
+    reviews: entry.reviews || [],
+    ...(entry.dev_blocked ? { dev_blocked: true } : {}),
+    ...(entry.moved_at ? { moved_at: entry.moved_at } : {}),
+  });
+};

package/templates/product-system/packages/shared/lib/markdown.ts

@@ -0,0 +1,205 @@
+/**
+ * Node content operations backed by Drizzle/Turso.
+ * Node body (sections) is stored in the nodes.body column as serialized markdown.
+ */
+
+import { eq } from 'drizzle-orm';
+import { getDb } from './db.js';
+import { nodes } from '../db/schema.js';
+import { REQUIRED_SECTIONS, COMMON_OPTIONAL_SECTIONS } from './constants.js';
+import { scoreNode } from './completeness.js';
+
+/**
+ * Parse a section-based markdown body into a { sectionName: content } map.
+ * Sections are delimited by `## Section Name` headers.
+ */
+const parseSections = (body) => {
+  const sections = {};
+  const lines = body.split('\n');
+  let currentSection = null;
+  let currentLines = [];
+
+  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;
+};
+
+/**
+ * Serialize sections map back into markdown body text.
+ */
+const serializeSections = (sections) => {
+  const parts = [];
+  for (const [name, content] of Object.entries(sections)) {
+    parts.push(`## ${name}`);
+    if (content.trim()) {
+      parts.push(content.trim());
+    }
+    parts.push(''); // blank line after section
+  }
+  return parts.join('\n');
+};
+
+/**
+ * Read a node's content from the database.
+ * Accepts a node ID string (e.g. "feat_001").
+ * Returns { frontmatter, sections }.
+ */
+export const readNode = async (nodeId) => {
+  const db = getDb();
+
+  const rows = await db.select().from(nodes).where(eq(nodes.id, nodeId));
+  const row = rows[0];
+  if (!row) {
+    throw new Error(`Node not found in database: ${nodeId}`);
+  }
+
+  // Reconstruct frontmatter from structured columns
+  const frontmatter = {
+    id: row.id,
+    type: row.type,
+    name: row.name,
+    status: row.status,
+    priority: row.priority,
+    ...(row.kind ? { kind: row.kind } : {}),
+    created_at: row.createdAt,
+    updated_at: row.updatedAt,
+  };
+
+  // Parse sections from body column
+  const body = row.body || '';
+  const sections = parseSections(body);
+
+  return { frontmatter, sections };
+};
+
+/**
+ * Write a node's content to the database.
+ * Accepts a node ID string (e.g. "feat_001").
+ */
+export const writeNode = async (nodeId, frontmatter, sections) => {
+  const db = getDb();
+
+  const body = serializeSections(sections);
+
+  const updates = {
+    type: frontmatter.type,
+    name: frontmatter.name,
+    status: frontmatter.status,
+    priority: frontmatter.priority || 'medium',
+    kind: frontmatter.kind || null,
+    updatedAt: frontmatter.updated_at || new Date().toISOString(),
+    body,
+  };
+
+  // Check if node exists — update or insert
+  const existing = await db.select({ id: nodes.id }).from(nodes).where(eq(nodes.id, nodeId));
+  if (existing.length > 0) {
+    await db.update(nodes).set(updates).where(eq(nodes.id, nodeId));
+  } else {
+    await db.insert(nodes).values({
+      id: nodeId,
+      ...updates,
+      completeness: 0,
+      openQuestionsCount: 0,
+      createdAt: frontmatter.created_at || new Date().toISOString(),
+    });
+  }
+};
+
+/**
+ * Get the content of a specific section.
+ */
+export const getSection = (sections, name) => {
+  return sections[name] || '';
+};
+
+/**
+ * Set the content of a specific section (creates it if missing).
+ */
+export const setSection = (sections, name, content) => {
+  sections[name] = content;
+  return sections;
+};
+
+/**
+ * Append a line to a section (creates section if missing).
+ */
+export const appendToSection = (sections, name, line) => {
+  const existing = sections[name] || '';
+  sections[name] = existing ? existing + '\n' + line : line;
+  return sections;
+};
+
+/**
+ * Move a line from one section to another (e.g., open question → resolved).
+ * The line is matched by substring. Returns true if moved, false if not found.
+ */
+export const moveLineAcrossSections = (sections, fromSection, toSection, line) => {
+  const fromContent = sections[fromSection] || '';
+  const lines = fromContent.split('\n');
+  const idx = lines.findIndex(l => l.includes(line));
+
+  if (idx === -1) return false;
+
+  const removed = lines.splice(idx, 1)[0];
+  sections[fromSection] = lines.join('\n').trim();
+
+  const toContent = sections[toSection] || '';
+  sections[toSection] = toContent ? toContent + '\n' + removed : removed;
+
+  return true;
+};
+
+/**
+ * Derive graph.json metadata from a parsed node's frontmatter and sections.
+ * Returns { completeness, open_questions_count, status }.
+ */
+export const deriveMetadata = (frontmatter, sections, type) => {
+  const completeness = scoreNode(type, frontmatter, sections);
+
+  // Count open questions (unchecked checkboxes)
+  const oq = sections['Open Questions'] || '';
+  const open_questions_count = oq
+    .split('\n')
+    .filter(l => l.trim().startsWith('- [ ]'))
+    .length;
+
+  // Derive status if not explicitly set
+  let status = frontmatter.status || 'draft';
+  if (status === 'draft' && completeness > 0) {
+    status = 'partially_defined';
+  }
+
+  return { completeness, open_questions_count, status };
+};
+
+/**
+ * Build a template sections object for a given node type with all required
+ * section headers (empty content).
+ */
+export const templateSections = (type) => {
+  const required = REQUIRED_SECTIONS[type] || [];
+  const sections = {};
+  for (const name of required) {
+    sections[name] = '';
+  }
+  // Always include common optional sections
+  for (const name of COMMON_OPTIONAL_SECTIONS) {
+    sections[name] = '';
+  }
+  return sections;
+};

package/templates/product-system/packages/shared/lib/pipeline-state-store.ts

@@ -0,0 +1,124 @@
+/**
+ * PipelineStateStore — persists pipeline state to Turso via Drizzle.
+ * Dual-layer: in-memory Map for real-time updates, DB for persistence.
+ */
+
+import { eq } from 'drizzle-orm';
+import { pipelineState } from '../db/schema.js';
+
+export class PipelineStateStore {
+  constructor({ getDb }) {
+    this.getDb = getDb;
+  }
+
+  /**
+   * Persist the current pipeline state for a feature.
+   * @param {string} featureId
+   * @param {{ status: string, cycle: number, tasks?: object, toolCalls?: object, error?: string }} state
+   */
+  save = async (featureId, state, projectId?: string) => {
+    const db = this.getDb();
+    const row = {
+      featureId,
+      status: state.status,
+      cycle: state.cycle || 1,
+      tasksJson: state.tasks ? JSON.stringify(state.tasks.items || []) : null,
+      toolCallsJson: state.toolCalls ? JSON.stringify(state.toolCalls) : null,
+      workSummariesJson: state.workSummaries ? JSON.stringify(state.workSummaries) : null,
+      error: state.error || null,
+      updatedAt: new Date().toISOString(),
+      projectId: projectId || null,
+    };
+
+    await db.insert(pipelineState)
+      .values(row)
+      .onConflictDoUpdate({
+        target: pipelineState.featureId,
+        set: {
+          status: row.status,
+          cycle: row.cycle,
+          tasksJson: row.tasksJson,
+          toolCallsJson: row.toolCallsJson,
+          workSummariesJson: row.workSummariesJson,
+          error: row.error,
+          updatedAt: row.updatedAt,
+          projectId: row.projectId,
+        },
+      });
+  };
+
+  /**
+   * Load persisted pipeline state for a feature.
+   * Returns null if no entry exists.
+   * @param {string} featureId
+   * @returns {Promise<object|null>}
+   */
+  load = async (featureId) => {
+    const db = this.getDb();
+    const rows = await db.select().from(pipelineState).where(eq(pipelineState.featureId, featureId));
+    const row = rows[0];
+    if (!row) return null;
+
+    const tasks = row.tasksJson ? JSON.parse(row.tasksJson) : [];
+    const toolCalls = row.toolCallsJson ? JSON.parse(row.toolCallsJson) : null;
+    const rawSummaries = row.workSummariesJson ? JSON.parse(row.workSummariesJson) : [];
+
+    // Migrate old flat filesChanged format to categorized format
+    const workSummaries = rawSummaries.map((ws) => {
+      if (ws.filesChanged && !ws.filesUpdated) {
+        return {
+          ...ws,
+          filesCreated: [],
+          filesUpdated: ws.filesChanged,
+          filesDeleted: [],
+          filesChanged: undefined,
+        };
+      }
+      return ws;
+    });
+
+    return {
+      status: row.status,
+      cycle: row.cycle,
+      feature_id: row.featureId,
+      error: row.error || null,
+      tasks: tasks.length > 0 ? {
+        completed: tasks.filter(t => t.status === 'completed').length,
+        total: tasks.length,
+        items: tasks,
+      } : undefined,
+      toolCalls: toolCalls && toolCalls.total > 0 ? toolCalls : undefined,
+      workSummaries: workSummaries.length > 0 ? workSummaries : undefined,
+      updatedAt: row.updatedAt,
+    };
+  };
+
+  /**
+   * Remove persisted pipeline state for a feature.
+   * @param {string} featureId
+   */
+  remove = async (featureId) => {
+    const db = this.getDb();
+    await db.delete(pipelineState).where(eq(pipelineState.featureId, featureId));
+  };
+
+  /**
+   * Mark any active (non-terminal) pipeline states as 'interrupted'.
+   * Called on server startup to handle pipelines that were running when the server stopped.
+   */
+  markInterrupted = async (projectId?: string) => {
+    const db = this.getDb();
+    const activeStatuses = ['developing', 'reviewing', 'fixing_review', 'fixing_merge', 'merging', 'debugging', 'creating_worktree'];
+    const query = projectId
+      ? db.select().from(pipelineState).where(eq(pipelineState.projectId, projectId))
+      : db.select().from(pipelineState);
+    const allRows = await query;
+    for (const row of allRows) {
+      if (activeStatuses.includes(row.status)) {
+        await db.update(pipelineState)
+          .set({ status: 'interrupted', updatedAt: new Date().toISOString() })
+          .where(eq(pipelineState.featureId, row.featureId));
+      }
+    }
+  };
+}