@leanspec/ui 0.2.3 → 0.2.4

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

@@ -0,0 +1,216 @@
+/**
+ * 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/dist/standalone/packages/web/src/lib/dependency-graph.ts

@@ -0,0 +1,105 @@
+/**
+ * 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/dist/standalone/packages/web/src/lib/specs/service.ts

@@ -0,0 +1,120 @@
+/**
+ * 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/dist/standalone/packages/web/src/lib/specs/sources/database-source.ts

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