@leanspec/ui 0.2.9 → 0.2.10

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

@@ -1,76 +0,0 @@
-/**
- * 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/.next/standalone/packages/ui/dist/standalone/packages/web/src/lib/db/index.ts

@@ -1,42 +0,0 @@
-/**
- * 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/.next/standalone/packages/ui/dist/standalone/packages/web/src/lib/db/migrate.ts

@@ -1,18 +0,0 @@
-/**
- * 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/.next/standalone/packages/ui/dist/standalone/packages/web/src/lib/db/queries.ts

@@ -1,114 +0,0 @@
-/**
- * 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/.next/standalone/packages/ui/dist/standalone/packages/web/src/lib/db/schema.ts

@@ -1,123 +0,0 @@
-/**
- * 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/.next/standalone/packages/ui/dist/standalone/packages/web/src/lib/db/seed.ts

@@ -1,156 +0,0 @@
-/**
- * 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);
-});