@leanspec/ui 0.2.3 → 0.2.4

package/dist/standalone/packages/web/src/lib/date-utils.ts

@@ -0,0 +1,76 @@
+/**
+ * Utility functions for date formatting
+ */
+
+import dayjs from 'dayjs';
+import relativeTime from 'dayjs/plugin/relativeTime';
+
+dayjs.extend(relativeTime);
+
+/**
+ * Format a date as relative time (e.g., "2 days ago")
+ */
+export function formatRelativeTime(date: Date | string | number | null | undefined): string {
+  if (!date) return 'Unknown';
+  return dayjs(date).fromNow();
+}
+
+/**
+ * Format a date in a readable format (e.g., "Nov 12, 2025")
+ */
+export function formatDate(date: Date | string | number | null | undefined): string {
+  if (!date) return 'Unknown';
+  return dayjs(date).format('MMM D, YYYY');
+}
+
+/**
+ * Format a date with time (e.g., "Nov 12, 2025 10:30 AM")
+ */
+export function formatDateTime(date: Date | string | number | null | undefined): string {
+  if (!date) return 'Unknown';
+  return dayjs(date).format('MMM D, YYYY h:mm A');
+}
+
+/**
+ * Format duration between two dates in a human-readable format
+ */
+export function formatDuration(
+  start: Date | string | number | null | undefined,
+  end: Date | string | number | null | undefined
+): string {
+  if (!start || !end) return '';
+  
+  const startDate = dayjs(start);
+  const endDate = dayjs(end);
+  const diffMs = endDate.diff(startDate);
+  
+  if (diffMs < 0) return '';
+  
+  const days = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+  const hours = Math.floor((diffMs % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
+  
+  if (days === 0 && hours === 0) {
+    const minutes = Math.floor((diffMs % (1000 * 60 * 60)) / (1000 * 60));
+    if (minutes === 0) return '< 1m';
+    return `${minutes}m`;
+  }
+  
+  if (days === 0) {
+    return `${hours}h`;
+  }
+  
+  if (days < 30) {
+    return hours > 0 ? `${days}d ${hours}h` : `${days}d`;
+  }
+  
+  const months = Math.floor(days / 30);
+  const remainingDays = days % 30;
+  
+  if (months < 12) {
+    return remainingDays > 0 ? `${months}mo ${remainingDays}d` : `${months}mo`;
+  }
+  
+  const years = Math.floor(months / 12);
+  const remainingMonths = months % 12;
+  return remainingMonths > 0 ? `${years}y ${remainingMonths}mo` : `${years}y`;
+}

package/dist/standalone/packages/web/src/lib/db/index.ts

@@ -0,0 +1,42 @@
+/**
+ * Database connection and client
+ */
+
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+import Database from 'better-sqlite3';
+import * as schema from './schema';
+import { join } from 'path';
+
+// Lazy database initialization
+let _db: ReturnType<typeof drizzle> | null = null;
+let _sqlite: Database.Database | null = null;
+
+/**
+ * Get or create database connection
+ * Only initializes when first accessed (lazy loading)
+ */
+export function getDb() {
+  if (!_db) {
+    // Database path - use local SQLite for development
+    const dbPath = process.env.DATABASE_PATH || join(process.cwd(), 'leanspec.db');
+    
+    // Create SQLite database connection
+    _sqlite = new Database(dbPath);
+    
+    // Create Drizzle client
+    _db = drizzle(_sqlite, { schema });
+  }
+  
+  return _db;
+}
+
+// Export schema for use in queries
+export { schema };
+
+// Legacy export for backward compatibility (will be lazy)
+export const db = new Proxy({} as ReturnType<typeof drizzle>, {
+  get(_target, prop, receiver) {
+    const realDb = getDb();
+    return Reflect.get(realDb as object, prop, receiver);
+  }
+});

package/dist/standalone/packages/web/src/lib/db/migrate.ts

@@ -0,0 +1,18 @@
+/**
+ * Run database migrations
+ */
+
+import { migrate } from 'drizzle-orm/better-sqlite3/migrator';
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+import Database from 'better-sqlite3';
+import { join } from 'path';
+
+const dbPath = process.env.DATABASE_PATH || join(process.cwd(), 'leanspec.db');
+const sqlite = new Database(dbPath);
+const db = drizzle(sqlite);
+
+console.log('Running migrations...');
+migrate(db, { migrationsFolder: './drizzle' });
+console.log('Migrations complete!');
+
+sqlite.close();

package/dist/standalone/packages/web/src/lib/db/queries.ts

@@ -0,0 +1,114 @@
+/**
+ * Database queries for projects and specs
+ */
+
+import { db, schema } from './index';
+import { eq, desc } from 'drizzle-orm';
+import { detectSubSpecs } from '../sub-specs';
+import { join } from 'path';
+
+// Projects
+export async function getProjects() {
+  return await db.select().from(schema.projects).orderBy(desc(schema.projects.isFeatured), schema.projects.displayName);
+}
+
+export async function getProjectById(id: string) {
+  const results = await db.select().from(schema.projects).where(eq(schema.projects.id, id)).limit(1);
+  return results[0] || null;
+}
+
+export async function getFeaturedProjects() {
+  return await db.select().from(schema.projects).where(eq(schema.projects.isFeatured, true));
+}
+
+// Specs
+export async function getSpecs() {
+  const results = await db.select().from(schema.specs).orderBy(schema.specs.specNumber);
+  return results.map(spec => ({
+    ...spec,
+    tags: spec.tags ? JSON.parse(spec.tags) : null,
+  }));
+}
+
+export async function getSpecById(id: string) {
+  // Support both uuid and spec number (e.g., "035" or "35")
+  let results;
+  
+  // Check if id is numeric (spec number)
+  const specNum = parseInt(id, 10);
+  if (!isNaN(specNum)) {
+    results = await db.select().from(schema.specs).where(eq(schema.specs.specNumber, specNum)).limit(1);
+  } else {
+    // Fallback to uuid lookup
+    results = await db.select().from(schema.specs).where(eq(schema.specs.id, id)).limit(1);
+  }
+  
+  if (results.length === 0) return null;
+  const spec = results[0];
+  
+  // Detect sub-specs from filesystem
+  const specDirPath = join(process.cwd(), '../../specs', spec.filePath.replace('/README.md', '').replace('specs/', ''));
+  const subSpecs = detectSubSpecs(specDirPath);
+  
+  return {
+    ...spec,
+    tags: spec.tags ? JSON.parse(spec.tags) : null,
+    subSpecs,
+  };
+}
+
+export async function getSpecsByProjectId(projectId: string) {
+  const results = await db.select().from(schema.specs).where(eq(schema.specs.projectId, projectId)).orderBy(schema.specs.specNumber);
+  return results.map(spec => ({
+    ...spec,
+    tags: spec.tags ? JSON.parse(spec.tags) : null,
+  }));
+}
+
+export async function getSpecsByStatus(status: 'planned' | 'in-progress' | 'complete' | 'archived') {
+  const results = await db.select().from(schema.specs).where(eq(schema.specs.status, status)).orderBy(schema.specs.specNumber);
+  return results.map(spec => ({
+    ...spec,
+    tags: spec.tags ? JSON.parse(spec.tags) : null,
+  }));
+}
+
+// Stats
+export interface StatsResult {
+  totalProjects: number;
+  totalSpecs: number;
+  specsByStatus: { status: string; count: number }[];
+  specsByPriority: { priority: string; count: number }[];
+  completionRate: number;
+}
+
+export async function getStats(): Promise<StatsResult> {
+  const [projects, specs] = await Promise.all([
+    db.select().from(schema.projects),
+    db.select().from(schema.specs),
+  ]);
+
+  // Count by status
+  const statusCounts = new Map<string, number>();
+  const priorityCounts = new Map<string, number>();
+  
+  for (const spec of specs) {
+    if (spec.status) {
+      statusCounts.set(spec.status, (statusCounts.get(spec.status) || 0) + 1);
+    }
+    if (spec.priority) {
+      priorityCounts.set(spec.priority, (priorityCounts.get(spec.priority) || 0) + 1);
+    }
+  }
+
+  const completeCount = statusCounts.get('complete') || 0;
+  const completionRate = specs.length > 0 ? (completeCount / specs.length) * 100 : 0;
+
+  return {
+    totalProjects: projects.length,
+    totalSpecs: specs.length,
+    specsByStatus: Array.from(statusCounts.entries()).map(([status, count]) => ({ status, count })),
+    specsByPriority: Array.from(priorityCounts.entries()).map(([priority, count]) => ({ priority, count })),
+    completionRate: Math.round(completionRate * 10) / 10,
+  };
+}

package/dist/standalone/packages/web/src/lib/db/schema.ts

@@ -0,0 +1,123 @@
+/**
+ * Database schema for LeanSpec Web
+ * Using Drizzle ORM with SQLite (development) / PostgreSQL (production)
+ */
+
+import { sqliteTable, text, integer, uniqueIndex } from 'drizzle-orm/sqlite-core';
+import { relations } from 'drizzle-orm';
+
+// Projects table - GitHub repositories using LeanSpec
+export const projects = sqliteTable('projects', {
+  id: text('id').primaryKey(),
+  githubOwner: text('github_owner').notNull(),
+  githubRepo: text('github_repo').notNull(),
+  displayName: text('display_name'),
+  description: text('description'),
+  homepageUrl: text('homepage_url'),
+  stars: integer('stars').default(0),
+  isPublic: integer('is_public', { mode: 'boolean' }).default(true),
+  isFeatured: integer('is_featured', { mode: 'boolean' }).default(false),
+  lastSyncedAt: integer('last_synced_at', { mode: 'timestamp' }),
+  createdAt: integer('created_at', { mode: 'timestamp' }).notNull().$defaultFn(() => new Date()),
+  updatedAt: integer('updated_at', { mode: 'timestamp' }).notNull().$defaultFn(() => new Date()),
+});
+
+// Specs table - Cached specification content from GitHub
+export const specs = sqliteTable('specs', {
+  id: text('id').primaryKey(),
+  projectId: text('project_id').notNull().references(() => projects.id, { onDelete: 'cascade' }),
+  specNumber: integer('spec_number'),
+  specName: text('spec_name').notNull(),
+  title: text('title'),
+  status: text('status', { 
+    enum: ['planned', 'in-progress', 'complete', 'archived'] 
+  }),
+  priority: text('priority', { 
+    enum: ['low', 'medium', 'high', 'critical'] 
+  }),
+  tags: text('tags'), // JSON string array
+  assignee: text('assignee'),
+  contentMd: text('content_md').notNull(), // Full markdown content
+  contentHtml: text('content_html'), // Pre-rendered HTML (optional optimization)
+  createdAt: integer('created_at', { mode: 'timestamp' }),
+  updatedAt: integer('updated_at', { mode: 'timestamp' }),
+  completedAt: integer('completed_at', { mode: 'timestamp' }),
+  filePath: text('file_path').notNull(), // Path in repo
+  githubUrl: text('github_url'), // Direct GitHub file link
+  syncedAt: integer('synced_at', { mode: 'timestamp' }).notNull().$defaultFn(() => new Date()),
+}, (table) => ({
+  // Unique constraint on projectId + specNumber (prevent duplicates within a project)
+  uniqueSpecNumber: uniqueIndex('unique_spec_number').on(table.projectId, table.specNumber),
+}));
+
+// Spec relationships table - Tracks dependencies between specs
+export const specRelationships = sqliteTable('spec_relationships', {
+  id: text('id').primaryKey(),
+  specId: text('spec_id').notNull().references(() => specs.id, { onDelete: 'cascade' }),
+  relatedSpecId: text('related_spec_id').notNull().references(() => specs.id, { onDelete: 'cascade' }),
+  relationshipType: text('relationship_type', {
+    enum: ['depends_on', 'related']
+  }).notNull(),
+  createdAt: integer('created_at', { mode: 'timestamp' }).notNull().$defaultFn(() => new Date()),
+});
+
+// Sync logs table - Audit trail for GitHub sync operations
+export const syncLogs = sqliteTable('sync_logs', {
+  id: text('id').primaryKey(),
+  projectId: text('project_id').notNull().references(() => projects.id, { onDelete: 'cascade' }),
+  status: text('status', {
+    enum: ['pending', 'running', 'success', 'failed']
+  }).notNull(),
+  specsAdded: integer('specs_added').default(0),
+  specsUpdated: integer('specs_updated').default(0),
+  specsDeleted: integer('specs_deleted').default(0),
+  errorMessage: text('error_message'),
+  startedAt: integer('started_at', { mode: 'timestamp' }).notNull().$defaultFn(() => new Date()),
+  completedAt: integer('completed_at', { mode: 'timestamp' }),
+  durationMs: integer('duration_ms'),
+});
+
+// Define relations
+export const projectsRelations = relations(projects, ({ many }) => ({
+  specs: many(specs),
+  syncLogs: many(syncLogs),
+}));
+
+export const specsRelations = relations(specs, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [specs.projectId],
+    references: [projects.id],
+  }),
+  dependencies: many(specRelationships, { relationName: 'spec' }),
+  dependents: many(specRelationships, { relationName: 'relatedSpec' }),
+}));
+
+export const specRelationshipsRelations = relations(specRelationships, ({ one }) => ({
+  spec: one(specs, {
+    fields: [specRelationships.specId],
+    references: [specs.id],
+    relationName: 'spec',
+  }),
+  relatedSpec: one(specs, {
+    fields: [specRelationships.relatedSpecId],
+    references: [specs.id],
+    relationName: 'relatedSpec',
+  }),
+}));
+
+export const syncLogsRelations = relations(syncLogs, ({ one }) => ({
+  project: one(projects, {
+    fields: [syncLogs.projectId],
+    references: [projects.id],
+  }),
+}));
+
+// Export types
+export type Project = typeof projects.$inferSelect;
+export type NewProject = typeof projects.$inferInsert;
+export type Spec = typeof specs.$inferSelect;
+export type NewSpec = typeof specs.$inferInsert;
+export type SpecRelationship = typeof specRelationships.$inferSelect;
+export type NewSpecRelationship = typeof specRelationships.$inferInsert;
+export type SyncLog = typeof syncLogs.$inferSelect;
+export type NewSyncLog = typeof syncLogs.$inferInsert;

package/dist/standalone/packages/web/src/lib/db/seed.ts

@@ -0,0 +1,156 @@
+/**
+ * Seed database with LeanSpec's own specs
+ */
+
+import { db, schema } from './index';
+import matter from 'gray-matter';
+import { readFileSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import { randomUUID } from 'crypto';
+import { eq } from 'drizzle-orm';
+
+// Path to specs directory (relative to monorepo root)
+const SPECS_DIR = join(process.cwd(), '../../specs');
+
+type Frontmatter = {
+  title?: string;
+  status?: 'planned' | 'in-progress' | 'complete' | 'archived';
+  priority?: 'low' | 'medium' | 'high' | 'critical';
+  tags?: string[];
+  assignee?: string;
+  created?: string;
+  created_at?: string;
+  updated?: string;
+  updated_at?: string;
+  completed?: string;
+  completed_at?: string;
+};
+
+interface ParsedSpec {
+  number: number | null;
+  name: string;
+  frontmatter: Frontmatter;
+  content: string;
+  filePath: string;
+}
+
+function parseSpecDirectory(dirPath: string): ParsedSpec | null {
+  try {
+    const readmePath = join(dirPath, 'README.md');
+    const content = readFileSync(readmePath, 'utf-8');
+    const { data: frontmatter, content: markdownContent } = matter(content);
+    
+    // Extract spec number and name from directory name
+    const dirName = dirPath.split('/').pop() || '';
+    const match = dirName.match(/^(\d+)-(.+)$/);
+    const specNumber = match ? parseInt(match[1], 10) : null;
+    const specName = match ? match[2] : dirName;
+    
+    return {
+      number: specNumber,
+      name: specName,
+      frontmatter: frontmatter as Frontmatter,
+      content: markdownContent, // Use the parsed content without frontmatter
+      filePath: `specs/${dirName}/README.md`,
+    };
+  } catch (error) {
+    console.error(`Failed to parse spec ${dirPath}:`, error);
+    return null;
+  }
+}
+
+function getAllSpecs(): ParsedSpec[] {
+  const specs: ParsedSpec[] = [];
+  const entries = readdirSync(SPECS_DIR);
+  
+  for (const entry of entries) {
+    const entryPath = join(SPECS_DIR, entry);
+    const stat = statSync(entryPath);
+    
+    // Skip archived specs and non-directories
+    if (!stat.isDirectory() || entry === 'archived') {
+      continue;
+    }
+    
+    const spec = parseSpecDirectory(entryPath);
+    if (spec) {
+      specs.push(spec);
+    }
+  }
+  
+  return specs.sort((a, b) => (a.number || 0) - (b.number || 0));
+}
+
+async function seed() {
+  console.log('Seeding database with LeanSpec specs...');
+  
+  // Clear existing data for LeanSpec project (idempotent seed)
+  console.log('Clearing existing LeanSpec data...');
+  const existingProjects = await db
+    .select()
+    .from(schema.projects)
+    .where(eq(schema.projects.githubRepo, 'lean-spec'));
+  
+  for (const project of existingProjects) {
+    // Cascade delete will remove associated specs
+    await db.delete(schema.projects).where(eq(schema.projects.id, project.id));
+  }
+  
+  // Create LeanSpec project
+  const projectId = randomUUID();
+  await db.insert(schema.projects).values({
+    id: projectId,
+    githubOwner: 'codervisor',
+    githubRepo: 'lean-spec',
+    displayName: 'LeanSpec',
+    description: 'Lightweight spec methodology for AI-powered development',
+    homepageUrl: 'https://lean-spec.dev',
+    stars: 0,
+    isPublic: true,
+    isFeatured: true,
+    lastSyncedAt: new Date(),
+  });
+  
+  console.log(`Created project: ${projectId}`);
+  
+  // Load and insert specs
+  const specs = getAllSpecs();
+  console.log(`Found ${specs.length} specs`);
+  
+  for (const spec of specs) {
+    const specId = randomUUID();
+    const fm = spec.frontmatter;
+    const parseDate = (value?: string) => (value ? new Date(value) : null);
+    const created = fm.created_at ?? fm.created;
+    const updated = fm.updated_at ?? fm.updated;
+    const completed = fm.completed_at ?? fm.completed;
+    
+    await db.insert(schema.specs).values({
+      id: specId,
+      projectId,
+      specNumber: spec.number,
+      specName: spec.name,
+      title: fm.title || spec.name,
+      status: fm.status || 'planned',
+      priority: fm.priority || 'medium',
+      tags: fm.tags ? JSON.stringify(fm.tags) : null,
+      assignee: fm.assignee || null,
+      contentMd: spec.content,
+      createdAt: parseDate(created),
+      updatedAt: parseDate(updated),
+      completedAt: parseDate(completed),
+      filePath: spec.filePath,
+      githubUrl: `https://github.com/codervisor/lean-spec/blob/main/${spec.filePath}`,
+      syncedAt: new Date(),
+    });
+    
+    console.log(`Inserted spec ${spec.number}: ${spec.name}`);
+  }
+  
+  console.log('Seed complete!');
+}
+
+seed().catch((error) => {
+  console.error('Seed failed:', error);
+  process.exit(1);
+});