@leanspec/ui 0.2.5 → 0.2.6-dev.20251125015611

package/.next/standalone/packages/ui/dist/standalone/packages/web/src/lib/db/service-queries.ts

@@ -1,216 +0,0 @@
-/**
- * Service-based data access functions
- * These replace direct database queries with the unified specs service
- */
-
-import { specsService } from '../specs/service';
-import type { Spec } from './schema';
-import { detectSubSpecs } from '../sub-specs';
-import { join, resolve } from 'path';
-import { readFileSync } from 'node:fs';
-import matter from 'gray-matter';
-
-/**
- * Spec with parsed tags (for client consumption)
- */
-export type ParsedSpec = Omit<Spec, 'tags'> & {
-  tags: string[] | null;
-};
-
-const DEFAULT_SPECS_DIR = resolve(process.cwd(), '../../specs');
-
-function getSpecsRootDir(): string {
-  const envDir = process.env.SPECS_DIR;
-  if (!envDir) {
-    return DEFAULT_SPECS_DIR;
-  }
-  return envDir.startsWith('/') ? envDir : resolve(process.cwd(), envDir);
-}
-
-function buildSpecDirPath(filePath: string): string {
-  const normalized = filePath
-    .replace(/^specs\//, '')
-    .replace(/\/README\.md$/, '');
-  return join(getSpecsRootDir(), normalized);
-}
-
-interface SpecRelationships {
-  dependsOn: string[];
-  related: string[];
-}
-function normalizeRelationshipList(value: unknown): string[] {
-  if (!value) return [];
-  if (Array.isArray(value)) {
-    return value.map((entry) => String(entry));
-  }
-  if (typeof value === 'string') {
-    return [value];
-  }
-  return [];
-}
-
-function getFilesystemRelationships(specDirPath: string): SpecRelationships {
-  try {
-    const readmePath = join(specDirPath, 'README.md');
-    const raw = readFileSync(readmePath, 'utf-8');
-    const { data } = matter(raw);
-    const dependsOn = normalizeRelationshipList(data?.depends_on ?? data?.dependsOn);
-    const related = normalizeRelationshipList(data?.related);
-    return {
-      dependsOn,
-      related,
-    };
-  } catch (error) {
-    console.warn('Unable to parse spec relationships', error);
-    return { dependsOn: [], related: [] };
-  }
-}
-
-/**
- * Parse tags from JSON string to array
- */
-function parseSpecTags(spec: Spec): ParsedSpec {
-  return {
-    ...spec,
-    tags: spec.tags ? (typeof spec.tags === 'string' ? JSON.parse(spec.tags) : spec.tags) : null,
-  };
-}
-
-/**
- * Count sub-specs in a directory
- */
-function countSubSpecs(specDirPath: string): number {
-  try {
-    const { readdirSync, existsSync, statSync } = require('fs');
-    if (!existsSync(specDirPath)) return 0;
-    
-    const entries = readdirSync(specDirPath);
-    let count = 0;
-    
-    for (const entry of entries) {
-      // Skip README.md (main spec file) and non-.md files
-      if (entry === 'README.md' || !entry.endsWith('.md')) {
-        continue;
-      }
-      
-      const filePath = join(specDirPath, entry);
-      try {
-        const stat = statSync(filePath);
-        if (stat.isFile()) {
-          count++;
-        }
-      } catch {
-        // Skip files that can't be accessed
-      }
-    }
-    
-    return count;
-  } catch {
-    return 0;
-  }
-}
-
-/**
- * Get all specs (uses filesystem by default, database if projectId provided)
- */
-export async function getSpecs(projectId?: string): Promise<ParsedSpec[]> {
-  const specs = await specsService.getAllSpecs(projectId);
-  return specs.map(parseSpecTags);
-}
-
-/**
- * Get all specs with sub-spec count (for sidebar)
- */
-export async function getSpecsWithSubSpecCount(projectId?: string): Promise<(ParsedSpec & { subSpecsCount: number })[]> {
-  const specs = await specsService.getAllSpecs(projectId);
-  
-  // Only count sub-specs for filesystem mode
-  if (projectId) {
-    return specs.map(spec => ({ ...parseSpecTags(spec), subSpecsCount: 0 }));
-  }
-  
-  return specs.map(spec => {
-    const specDirPath = buildSpecDirPath(spec.filePath);
-    const subSpecsCount = countSubSpecs(specDirPath);
-    return { ...parseSpecTags(spec), subSpecsCount };
-  });
-}
-
-/**
- * Get a spec by ID (number or UUID)
- */
-export async function getSpecById(id: string, projectId?: string): Promise<(ParsedSpec & { subSpecs?: import('../sub-specs').SubSpec[]; relationships?: SpecRelationships }) | null> {
-  const spec = await specsService.getSpec(id, projectId);
-
-  if (!spec) return null;
-
-  const parsedSpec = parseSpecTags(spec);
-
-  // Detect sub-specs from filesystem (only for filesystem mode)
-  if (!projectId) {
-    const specDirPath = buildSpecDirPath(spec.filePath);
-    const subSpecs = detectSubSpecs(specDirPath);
-    const relationships = getFilesystemRelationships(specDirPath);
-    return { ...parsedSpec, subSpecs, relationships };
-  }
-
-  return parsedSpec;
-}
-
-/**
- * Get specs by status
- */
-export async function getSpecsByStatus(
-  status: 'planned' | 'in-progress' | 'complete' | 'archived',
-  projectId?: string
-): Promise<ParsedSpec[]> {
-  const specs = await specsService.getSpecsByStatus(status, projectId);
-  return specs.map(parseSpecTags);
-}
-
-/**
- * Search specs
- */
-export async function searchSpecs(query: string, projectId?: string): Promise<ParsedSpec[]> {
-  const specs = await specsService.searchSpecs(query, projectId);
-  return specs.map(parseSpecTags);
-}
-
-/**
- * Stats calculation
- */
-export interface StatsResult {
-  totalProjects: number;
-  totalSpecs: number;
-  specsByStatus: { status: string; count: number }[];
-  specsByPriority: { priority: string; count: number }[];
-  completionRate: number;
-}
-
-export async function getStats(projectId?: string): Promise<StatsResult> {
-  const specs = await specsService.getAllSpecs(projectId);
-
-  // 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: 1, // For now, single project (LeanSpec)
-    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/dependency-graph.ts

@@ -1,105 +0,0 @@
-/**
- * Dependency Graph for Web API
- * Standalone implementation to avoid tiktoken wasm issues from @leanspec/core
- */
-
-export interface SpecFrontmatter {
-  status: string;
-  created: string;
-  depends_on?: string[];
-  related?: string[];
-  priority?: string;
-  tags?: string[];
-  assignee?: string;
-}
-
-export interface SpecInfo {
-  path: string;
-  fullPath: string;
-  filePath: string;
-  name: string;
-  frontmatter: SpecFrontmatter;
-}
-
-interface DependencyNode {
-  dependsOn: Set<string>;
-  requiredBy: Set<string>;
-  related: Set<string>;
-}
-
-export interface CompleteDependencyGraph {
-  current: SpecInfo;
-  dependsOn: SpecInfo[];
-  requiredBy: SpecInfo[];
-  related: SpecInfo[];
-}
-
-/**
- * Dependency graph builder
- */
-export class SpecDependencyGraph {
-  private graph: Map<string, DependencyNode>;
-  private specs: Map<string, SpecInfo>;
-
-  constructor(allSpecs: SpecInfo[]) {
-    this.graph = new Map();
-    this.specs = new Map();
-    this.buildGraph(allSpecs);
-  }
-
-  private buildGraph(specs: SpecInfo[]): void {
-    // First pass: Initialize all nodes
-    for (const spec of specs) {
-      this.specs.set(spec.path, spec);
-      this.graph.set(spec.path, {
-        dependsOn: new Set(spec.frontmatter.depends_on || []),
-        requiredBy: new Set(),
-        related: new Set(spec.frontmatter.related || []),
-      });
-    }
-
-    // Second pass: Build reverse edges
-    for (const [specPath, node] of this.graph.entries()) {
-      // For each dependsOn, add reverse requiredBy edge
-      for (const dep of node.dependsOn) {
-        const depNode = this.graph.get(dep);
-        if (depNode) {
-          depNode.requiredBy.add(specPath);
-        }
-      }
-      
-      // For each related, add bidirectional link
-      for (const rel of node.related) {
-        const relNode = this.graph.get(rel);
-        if (relNode) {
-          relNode.related.add(specPath);
-        }
-      }
-    }
-  }
-
-  getCompleteGraph(specPath: string): CompleteDependencyGraph {
-    const spec = this.specs.get(specPath);
-    if (!spec) {
-      throw new Error(`Spec not found: ${specPath}`);
-    }
-
-    const node = this.graph.get(specPath);
-    if (!node) {
-      throw new Error(`Graph node not found: ${specPath}`);
-    }
-
-    return {
-      current: spec,
-      dependsOn: this.getSpecsByPaths(Array.from(node.dependsOn)),
-      requiredBy: this.getSpecsByPaths(Array.from(node.requiredBy)),
-      related: this.getSpecsByPaths(Array.from(node.related)),
-    };
-  }
-
-  private getSpecsByPaths(paths: string[]): SpecInfo[] {
-    return paths
-      .map(path => this.specs.get(path))
-      .filter((spec): spec is SpecInfo => spec !== undefined);
-  }
-}

package/.next/standalone/packages/ui/dist/standalone/packages/web/src/lib/specs/service.ts

@@ -1,120 +0,0 @@
-/**
- * Unified specs service
- * Routes requests to filesystem or database source based on configuration
- */
-
-import { FilesystemSource } from './sources/filesystem-source';
-import type { SpecSource } from './types';
-import type { Spec } from '../db/schema';
-
-// Lazy import DatabaseSource to avoid DB connection issues in filesystem mode
-type DatabaseSourceConstructor = new () => SpecSource;
-let DatabaseSourceCtor: DatabaseSourceConstructor | null = null;
-
-/**
- * Service modes
- * - filesystem: Read from local filesystem only (LeanSpec's own specs)
- * - database: Read from database only (external repos)
- * - both: Support both modes (route based on projectId)
- */
-type SpecsMode = 'filesystem' | 'database' | 'both';
-
-/**
- * Unified specs service
- * Provides a single interface for accessing specs from different sources
- */
-export class SpecsService {
-  private filesystemSource?: FilesystemSource;
-  private databaseSource?: SpecSource;
-  private mode: SpecsMode;
-
-  constructor() {
-    this.mode = (process.env.SPECS_MODE as SpecsMode) || 'filesystem';
-
-    if (this.mode === 'filesystem' || this.mode === 'both') {
-      const specsDir = process.env.SPECS_DIR;
-      this.filesystemSource = new FilesystemSource(specsDir);
-    }
-
-    // Don't instantiate database source here - do it lazily
-  }
-
-  /**
-   * Lazy load database source
-   */
-  private async getDatabaseSource(): Promise<SpecSource> {
-    if (!this.databaseSource) {
-      if (!DatabaseSourceCtor) {
-        const { DatabaseSource } = await import('./sources/database-source');
-        DatabaseSourceCtor = DatabaseSource;
-      }
-      this.databaseSource = new DatabaseSourceCtor();
-    }
-    return this.databaseSource;
-  }
-
-  /**
-   * Get all specs
-   * If projectId is provided, uses database source (external repo)
-   * Otherwise uses filesystem source (LeanSpec's own specs)
-   */
-  async getAllSpecs(projectId?: string): Promise<Spec[]> {
-    const source = await this.getSource(projectId);
-    return await source.getAllSpecs(projectId);
-  }
-
-  /**
-   * Get a single spec
-   */
-  async getSpec(specPath: string, projectId?: string): Promise<Spec | null> {
-    const source = await this.getSource(projectId);
-    return await source.getSpec(specPath, projectId);
-  }
-
-  /**
-   * Get specs by status
-   */
-  async getSpecsByStatus(
-    status: 'planned' | 'in-progress' | 'complete' | 'archived',
-    projectId?: string
-  ): Promise<Spec[]> {
-    const source = await this.getSource(projectId);
-    return await source.getSpecsByStatus(status, projectId);
-  }
-
-  /**
-   * Search specs
-   */
-  async searchSpecs(query: string, projectId?: string): Promise<Spec[]> {
-    const source = await this.getSource(projectId);
-    return await source.searchSpecs(query, projectId);
-  }
-
-  /**
-   * Invalidate cache
-   */
-  async invalidateCache(specPath?: string, projectId?: string): Promise<void> {
-    const source = await this.getSource(projectId);
-    source.invalidateCache(specPath);
-  }
-
-  /**
-   * Get the appropriate source based on projectId and mode
-   */
-  private async getSource(projectId?: string): Promise<SpecSource> {
-    // If projectId provided, use database (external repo)
-    if (projectId && (this.mode === 'database' || this.mode === 'both')) {
-      return await this.getDatabaseSource();
-    }
-
-    // Otherwise use filesystem (LeanSpec's own specs)
-    if (this.filesystemSource) {
-      return this.filesystemSource;
-    }
-
-    throw new Error('No spec source configured');
-  }
-}
-
-// Singleton instance
-export const specsService = new SpecsService();

package/.next/standalone/packages/ui/dist/standalone/packages/web/src/lib/specs/sources/database-source.ts

@@ -1,94 +0,0 @@
-/**
- * Database-backed spec source
- * Reads specs from PostgreSQL/SQLite database
- */
-
-import { db, schema } from '../../db';
-import { eq, and } from 'drizzle-orm';
-import type { SpecSource } from '../types';
-import type { Spec } from '../../db/schema';
-
-/**
- * Database source implementation
- * Reads specs from database (for external GitHub repos)
- */
-export class DatabaseSource implements SpecSource {
-  /**
-   * Get all specs, optionally filtered by projectId
-   */
-  async getAllSpecs(projectId?: string): Promise<Spec[]> {
-    const query = projectId
-      ? db.select().from(schema.specs).where(eq(schema.specs.projectId, projectId))
-      : db.select().from(schema.specs);
-
-    return await query.orderBy(schema.specs.specNumber);
-  }
-
-  /**
-   * Get a single spec by path and projectId
-   */
-  async getSpec(specPath: string, projectId?: string): Promise<Spec | null> {
-    if (!projectId) {
-      return null; // Database mode requires projectId
-    }
-
-    // Parse spec number from path (e.g., "035" or "035-my-spec")
-    const specNum = parseInt(specPath.split('-')[0], 10);
-    if (isNaN(specNum)) {
-      return null;
-    }
-
-    const results = await db
-      .select()
-      .from(schema.specs)
-      .where(and(eq(schema.specs.projectId, projectId), eq(schema.specs.specNumber, specNum)))
-      .limit(1);
-
-    return results.length > 0 ? results[0] : null;
-  }
-
-  /**
-   * Get specs by status
-   */
-  async getSpecsByStatus(
-    status: 'planned' | 'in-progress' | 'complete' | 'archived',
-    projectId?: string
-  ): Promise<Spec[]> {
-    const conditions = [eq(schema.specs.status, status)];
-    if (projectId) {
-      conditions.push(eq(schema.specs.projectId, projectId));
-    }
-
-    return await db
-      .select()
-      .from(schema.specs)
-      .where(and(...conditions))
-      .orderBy(schema.specs.specNumber);
-  }
-
-  /**
-   * Search specs by query
-   */
-  async searchSpecs(query: string, projectId?: string): Promise<Spec[]> {
-    // TODO: Implement full-text search with database
-    // For now, just return all specs and filter in memory
-    const allSpecs = await this.getAllSpecs(projectId);
-    const lowerQuery = query.toLowerCase();
-
-    return allSpecs.filter((spec) => {
-      return (
-        spec.specName.toLowerCase().includes(lowerQuery) ||
-        spec.title?.toLowerCase().includes(lowerQuery) ||
-        spec.contentMd.toLowerCase().includes(lowerQuery)
-      );
-    });
-  }
-
-  /**
-   * Invalidate cache (no-op for database source)
-   */
-  invalidateCache(): void {
-    // Database source doesn't have its own cache
-    // Next.js handles caching at the page level
-  }
-}