jettypod 4.4.120 → 4.4.121

package/apps/dashboard/lib/db-bridge.ts

@@ -1,283 +0,0 @@
-// Database bridge - routes calls to IPC (Electron) or direct db (web)
-// This allows the same API route code to work in both environments
-
-import * as directDb from './db';
-
-// Type for recent project
-export interface RecentProject {
-  name: string;
-  path: string;
-  lastOpened?: string;
-}
-
-// Type for the Electron API exposed via preload
-interface ElectronAPI {
-  project: {
-    openDialog: () => Promise<{
-      success: boolean;
-      canceled?: boolean;
-      error?: string;
-      path?: string;
-    }>;
-    newProject: () => Promise<{
-      success: boolean;
-      canceled?: boolean;
-      error?: string;
-      path?: string;
-    }>;
-    getRecent: () => Promise<RecentProject[]>;
-    openRecent: (path: string) => Promise<{
-      success: boolean;
-      error?: string;
-      path?: string;
-    }>;
-  };
-  claudeCode: {
-    install: () => Promise<{
-      success: boolean;
-      error?: string;
-    }>;
-    isInstalled: () => Promise<boolean>;
-    isAuthenticated: () => Promise<boolean>;
-    login: () => Promise<{
-      success: boolean;
-      error?: string;
-    }>;
-    update: () => Promise<{
-      success: boolean;
-      error?: string;
-      output?: string;
-    }>;
-  };
-  access: {
-    validate: (code: string) => Promise<{
-      success: boolean;
-      error?: string;
-    }>;
-    getStatus: () => Promise<{
-      activated: boolean;
-      activatedAt?: string;
-    }>;
-  };
-  auth: {
-    loginWithGoogle: () => Promise<void>;
-    saveToken: (token: string, user: { email: string; plan?: string }) => Promise<void>;
-    getStatus: () => Promise<{
-      authenticated: boolean;
-      token?: string;
-      user?: { email: string; plan?: string };
-    }>;
-    getToken: () => Promise<string | null>;
-    logout: () => Promise<void>;
-    getPostLoginPath: () => Promise<string | null>;
-  };
-  subscription: {
-    createCheckout: (plan: string) => Promise<{ success: boolean; error?: string }>;
-    activate: (customerId: string) => Promise<{ success: boolean; error?: string }>;
-    getStatus: () => Promise<{ active: boolean; customerId?: string; activatedAt?: string }>;
-  };
-  billing: {
-    openCustomerPortal: () => Promise<{ success: boolean; error?: string }>;
-  };
-  shell: {
-    openPath: (filePath: string) => Promise<string>;
-  };
-  db: {
-    getKanbanData: (doneLimit?: number) => Promise<ReturnType<typeof directDb.getKanbanData>>;
-    getAllWorkItems: () => Promise<ReturnType<typeof directDb.getAllWorkItems>>;
-    getWorkItem: (id: number) => Promise<ReturnType<typeof directDb.getWorkItem>>;
-    getChildWorkItems: (parentId: number) => Promise<ReturnType<typeof directDb.getChildWorkItems>>;
-    updateWorkItemTitle: (id: number, title: string) => Promise<boolean>;
-    updateWorkItemStatus: (id: number, status: string) => Promise<boolean>;
-    updateWorkItemOrder: (id: number, displayOrder: number) => Promise<boolean>;
-    updateWorkItemEpic: (id: number, epicId: number | null) => Promise<boolean>;
-    getDecision: (id: number) => Promise<ReturnType<typeof directDb.getDecision>>;
-    getDecisionsForWorkItem: (workItemId: number) => Promise<ReturnType<typeof directDb.getDecisionsForWorkItem>>;
-    listSessions: () => Promise<ReturnType<typeof directDb.listSessions>>;
-    createSession: (title: string) => Promise<number>;
-    getSession: (sessionId: number) => Promise<ReturnType<typeof directDb.getSession>>;
-    closeSession: (sessionId: number) => Promise<boolean>;
-    closeSessionByWorkItem: (workItemId: number) => Promise<boolean>;
-    linkSession: (sessionId: number, workItemId: number) => Promise<ReturnType<typeof directDb.linkSession>>;
-    isLinkableWorkItem: (workItemId: number) => Promise<ReturnType<typeof directDb.isLinkableWorkItem>>;
-    getActiveSessionByWorkItem: (workItemId: number) => Promise<ReturnType<typeof directDb.getActiveSessionByWorkItem>>;
-    getOrCreateSessionForWorkItem: (workItemId: number) => Promise<ReturnType<typeof directDb.getOrCreateSessionForWorkItem>>;
-    countActiveSessions: () => Promise<number>;
-    cleanupStaleSessions: (retentionDays?: number) => Promise<number>;
-    getSessionContent: (sessionId: number) => Promise<ReturnType<typeof directDb.getSessionContent>>;
-    getSessionContentByWorkItem: (workItemId: number) => Promise<ReturnType<typeof directDb.getSessionContentByWorkItem>>;
-    appendSessionContent: (sessionId: number, turn: directDb.ConversationTurn) => Promise<boolean>;
-    appendSessionContentByWorkItem: (workItemId: number, turn: directDb.ConversationTurn) => Promise<boolean>;
-    getEnvVars: () => Promise<ReturnType<typeof directDb.getEnvVars>>;
-    setEnvVar: (name: string, value: string) => Promise<void>;
-    deleteEnvVar: (name: string) => Promise<void>;
-    getProjectName: () => Promise<string>;
-  };
-  isElectron: boolean;
-}
-
-declare global {
-  interface Window {
-    electronAPI?: ElectronAPI;
-  }
-}
-
-// Detect if running in Electron renderer process
-export function isElectron(): boolean {
-  // Server-side (API routes in Next.js) - check process
-  if (typeof window === 'undefined') {
-    // Check if we're in the Electron main process context
-    // This won't be true for Next.js API routes even in Electron
-    // because they run in a separate Node.js context
-    return false;
-  }
-  // Client-side - check for exposed API
-  return !!(window.electronAPI?.isElectron);
-}
-
-// For server-side code (API routes), we need a different detection mechanism
-// Since API routes run in the Next.js server, not the Electron renderer,
-// we use an environment variable set by the Electron main process
-export function isElectronServer(): boolean {
-  return process.env.ELECTRON_RUN_AS_NODE === '1' || process.env.IS_ELECTRON === '1';
-}
-
-// Re-export types from db
-export type {
-  WorkItem,
-  Decision,
-  KanbanGroup,
-  InFlightItem,
-  KanbanData,
-  ClaudeSession,
-  ConversationTurn,
-  SessionWithFeature,
-  SessionStatus,
-  EnvVar,
-  WeeklyUsage,
-} from './db';
-
-// ==================== Kanban ====================
-export function getKanbanData(doneLimit?: number): ReturnType<typeof directDb.getKanbanData> {
-  // Server-side always uses direct db (API routes)
-  return directDb.getKanbanData(doneLimit);
-}
-
-// ==================== Work Items ====================
-export function getAllWorkItems(): ReturnType<typeof directDb.getAllWorkItems> {
-  return directDb.getAllWorkItems();
-}
-
-export function getWorkItem(id: number): ReturnType<typeof directDb.getWorkItem> {
-  return directDb.getWorkItem(id);
-}
-
-export function getChildWorkItems(parentId: number): ReturnType<typeof directDb.getChildWorkItems> {
-  return directDb.getChildWorkItems(parentId);
-}
-
-export function updateWorkItemTitle(id: number, title: string): boolean {
-  return directDb.updateWorkItemTitle(id, title);
-}
-
-export function updateWorkItemStatus(id: number, status: string): boolean {
-  return directDb.updateWorkItemStatus(id, status);
-}
-
-export function updateWorkItemOrder(id: number, displayOrder: number): boolean {
-  return directDb.updateWorkItemOrder(id, displayOrder);
-}
-
-export function updateWorkItemEpic(id: number, epicId: number | null): boolean {
-  return directDb.updateWorkItemEpic(id, epicId);
-}
-
-// ==================== Decisions ====================
-export function getDecision(id: number): ReturnType<typeof directDb.getDecision> {
-  return directDb.getDecision(id);
-}
-
-export function getDecisionsForWorkItem(workItemId: number): ReturnType<typeof directDb.getDecisionsForWorkItem> {
-  return directDb.getDecisionsForWorkItem(workItemId);
-}
-
-// ==================== Sessions ====================
-export function listSessions(): ReturnType<typeof directDb.listSessions> {
-  return directDb.listSessions();
-}
-
-export function createSession(title: string): number {
-  return directDb.createSession(title);
-}
-
-export function getSession(sessionId: number): ReturnType<typeof directDb.getSession> {
-  return directDb.getSession(sessionId);
-}
-
-export function closeSession(sessionId: number): boolean {
-  return directDb.closeSession(sessionId);
-}
-
-export function closeSessionByWorkItem(workItemId: number): boolean {
-  return directDb.closeSessionByWorkItem(workItemId);
-}
-
-export function linkSession(sessionId: number, workItemId: number): ReturnType<typeof directDb.linkSession> {
-  return directDb.linkSession(sessionId, workItemId);
-}
-
-export function isLinkableWorkItem(workItemId: number): ReturnType<typeof directDb.isLinkableWorkItem> {
-  return directDb.isLinkableWorkItem(workItemId);
-}
-
-export function getActiveSessionByWorkItem(workItemId: number): ReturnType<typeof directDb.getActiveSessionByWorkItem> {
-  return directDb.getActiveSessionByWorkItem(workItemId);
-}
-
-export function getOrCreateSessionForWorkItem(workItemId: number): ReturnType<typeof directDb.getOrCreateSessionForWorkItem> {
-  return directDb.getOrCreateSessionForWorkItem(workItemId);
-}
-
-export function countActiveSessions(): number {
-  return directDb.countActiveSessions();
-}
-
-export function cleanupStaleSessions(retentionDays?: number): number {
-  return directDb.cleanupStaleSessions(retentionDays);
-}
-
-// ==================== Session Content ====================
-export function getSessionContent(sessionId: number): ReturnType<typeof directDb.getSessionContent> {
-  return directDb.getSessionContent(sessionId);
-}
-
-export function getSessionContentByWorkItem(workItemId: number): ReturnType<typeof directDb.getSessionContentByWorkItem> {
-  return directDb.getSessionContentByWorkItem(workItemId);
-}
-
-export function appendSessionContent(sessionId: number, turn: directDb.ConversationTurn): boolean {
-  return directDb.appendSessionContent(sessionId, turn);
-}
-
-export function appendSessionContentByWorkItem(workItemId: number, turn: directDb.ConversationTurn): boolean {
-  return directDb.appendSessionContentByWorkItem(workItemId, turn);
-}
-
-// ==================== Environment Variables ====================
-export function getEnvVars(): ReturnType<typeof directDb.getEnvVars> {
-  return directDb.getEnvVars();
-}
-
-export function setEnvVar(name: string, value: string): void {
-  return directDb.setEnvVar(name, value);
-}
-
-export function deleteEnvVar(name: string): void {
-  return directDb.deleteEnvVar(name);
-}
-
-// ==================== Project Info ====================
-export function getProjectName(): string {
-  return directDb.getProjectName();
-}
-

package/apps/dashboard/lib/prototypes.ts

@@ -1,202 +0,0 @@
-// Prototype data layer for the prototype browser
-// Scans prototypes directory and returns structured metadata
-
-import path from 'path';
-import fs from 'fs';
-import { execSync } from 'child_process';
-
-export interface PrototypeFile {
-  name: string;
-  type: string;
-  path: string;
-}
-
-export interface Prototype {
-  id: string;
-  title: string;
-  date: string;
-  month: string;
-  description: string;
-  feature: { id: number; title: string } | null;
-  files: PrototypeFile[];
-  path: string;
-}
-
-export interface PrototypeSummary {
-  total: number;
-  byMonth: Record<string, number>;
-}
-
-export interface PrototypeDashboardData {
-  prototypes: Prototype[];
-  summary: PrototypeSummary;
-}
-
-function getProjectRoot(): string {
-  if (process.env.JETTYPOD_PROJECT_PATH) {
-    return process.env.JETTYPOD_PROJECT_PATH;
-  }
-  try {
-    return execSync('git rev-parse --show-toplevel', { encoding: 'utf-8' }).trim();
-  } catch {
-    throw new Error('Not in a git repository and JETTYPOD_PROJECT_PATH not set');
-  }
-}
-
-// Parse date from filename or folder name
-// Formats: "2025-01-11-name" or "feature-123-name"
-function parseDate(name: string): Date | null {
-  // Try YYYY-MM-DD prefix
-  const dateMatch = name.match(/^(\d{4})-(\d{2})-(\d{2})/);
-  if (dateMatch) {
-    return new Date(parseInt(dateMatch[1]), parseInt(dateMatch[2]) - 1, parseInt(dateMatch[3]));
-  }
-  return null;
-}
-
-// Parse feature ID from folder name
-// Format: "feature-123-name"
-function parseFeatureId(name: string): number | null {
-  const featureMatch = name.match(/^feature-(\d+)-/);
-  if (featureMatch) {
-    return parseInt(featureMatch[1]);
-  }
-  return null;
-}
-
-// Format date as "January 2026"
-function formatMonth(date: Date): string {
-  return date.toLocaleDateString('en-US', { month: 'long', year: 'numeric' });
-}
-
-// Format date as "2026-01-27"
-function formatDate(date: Date): string {
-  return date.toISOString().split('T')[0];
-}
-
-// Convert slug to title
-function slugToTitle(slug: string): string {
-  // Remove date prefix if present
-  let title = slug.replace(/^\d{4}-\d{2}-\d{2}-/, '');
-  // Remove feature-id- prefix if present
-  title = title.replace(/^feature-\d+-/, '');
-  // Remove epic- prefix if present
-  title = title.replace(/^epic-/, '');
-  // Convert kebab-case to Title Case
-  return title
-    .split('-')
-    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
-    .join(' ');
-}
-
-// Get file extension type
-function getFileType(filename: string): string {
-  const ext = path.extname(filename).toLowerCase().slice(1);
-  return ext || 'unknown';
-}
-
-// Get files in a directory
-function getFilesInDir(dirPath: string): PrototypeFile[] {
-  const files: PrototypeFile[] = [];
-  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-
-  for (const entry of entries) {
-    if (entry.isFile() && !entry.name.startsWith('.')) {
-      files.push({
-        name: entry.name,
-        type: getFileType(entry.name),
-        path: path.join(dirPath, entry.name),
-      });
-    }
-  }
-
-  return files;
-}
-
-// Get modification time for a file or directory
-function getModTime(itemPath: string): Date {
-  const stats = fs.statSync(itemPath);
-  return stats.mtime;
-}
-
-// Main function to get prototype dashboard data
-export function getPrototypeDashboardData(): PrototypeDashboardData {
-  const projectRoot = getProjectRoot();
-  const prototypesDir = path.join(projectRoot, 'prototypes');
-
-  if (!fs.existsSync(prototypesDir)) {
-    return {
-      prototypes: [],
-      summary: { total: 0, byMonth: {} },
-    };
-  }
-
-  const prototypes: Prototype[] = [];
-  const entries = fs.readdirSync(prototypesDir, { withFileTypes: true });
-
-  for (const entry of entries) {
-    if (entry.name.startsWith('.')) continue;
-
-    const itemPath = path.join(prototypesDir, entry.name);
-
-    if (entry.isDirectory()) {
-      // Directory prototype (feature-xxx-name or topic-name)
-      const files = getFilesInDir(itemPath);
-      if (files.length === 0) continue;
-
-      const featureId = parseFeatureId(entry.name);
-      let date = parseDate(entry.name);
-
-      // If no date in name, use modification time
-      if (!date) {
-        date = getModTime(itemPath);
-      }
-
-      prototypes.push({
-        id: entry.name,
-        title: slugToTitle(entry.name),
-        date: formatDate(date),
-        month: formatMonth(date),
-        description: `${files.length} file${files.length > 1 ? 's' : ''}: ${files.map(f => f.name).join(', ')}`,
-        feature: featureId ? { id: featureId, title: `Feature #${featureId}` } : null,
-        files,
-        path: itemPath,
-      });
-    } else if (entry.isFile()) {
-      // Single file prototype (2025-01-11-name.js)
-      const date = parseDate(entry.name) || getModTime(itemPath);
-
-      prototypes.push({
-        id: entry.name,
-        title: slugToTitle(entry.name.replace(/\.[^.]+$/, '')),
-        date: formatDate(date),
-        month: formatMonth(date),
-        description: `Single file: ${entry.name}`,
-        feature: null,
-        files: [{
-          name: entry.name,
-          type: getFileType(entry.name),
-          path: itemPath,
-        }],
-        path: itemPath,
-      });
-    }
-  }
-
-  // Sort by date descending (newest first)
-  prototypes.sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime());
-
-  // Calculate summary
-  const byMonth: Record<string, number> = {};
-  for (const proto of prototypes) {
-    byMonth[proto.month] = (byMonth[proto.month] || 0) + 1;
-  }
-
-  return {
-    prototypes,
-    summary: {
-      total: prototypes.length,
-      byMonth,
-    },
-  };
-}