@leanspec/ui 0.2.9 → 0.2.10

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

@@ -18,6 +18,21 @@ export type ParsedSpec = Omit<Spec, 'tags'> & {
   tags: string[] | null;
 };
 
+/**
+ * Lightweight spec for list views (excludes contentMd to reduce payload size)
+ * The full contentMd can be 1MB+ for all specs combined
+ */
+export type LightweightSpec = Omit<ParsedSpec, 'contentMd' | 'contentHtml'>;
+
+/**
+ * Strip contentMd from a spec to create a lightweight version
+ */
+function toLightweightSpec<T extends ParsedSpec>(spec: T): Omit<T, 'contentMd' | 'contentHtml'> {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const { contentMd, contentHtml, ...rest } = spec;
+  return rest;
+}
+
 const DEFAULT_SPECS_DIR = resolve(process.cwd(), '../../specs');
 
 function getSpecsRootDir(): string {
@@ -37,7 +52,7 @@ function buildSpecDirPath(filePath: string): string {
 
 interface SpecRelationships {
   dependsOn: string[];
-  related: string[];
+  requiredBy: string[];
 }
 function normalizeRelationshipList(value: unknown): string[] {
   if (!value) return [];
@@ -56,23 +71,35 @@ function getFilesystemRelationships(specDirPath: string): SpecRelationships {
     const raw = readFileSync(readmePath, 'utf-8');
     const { data } = matter(raw);
     const dependsOn = normalizeRelationshipList(data?.depends_on ?? data?.dependsOn);
-    const related = normalizeRelationshipList(data?.related);
+    // Note: requiredBy is computed from the dependency graph, not stored in frontmatter
     return {
       dependsOn,
-      related,
+      requiredBy: [],
     };
   } catch (error) {
     console.warn('Unable to parse spec relationships', error);
-    return { dependsOn: [], related: [] };
+    return { dependsOn: [], requiredBy: [] };
   }
 }
 
 /**
- * Parse tags from JSON string to array
+ * Parse tags from JSON string to array and strip frontmatter from contentMd
  */
 function parseSpecTags(spec: Spec): ParsedSpec {
+  // Strip frontmatter from contentMd if present
+  let contentMd = spec.contentMd;
+  if (contentMd.startsWith('---')) {
+    try {
+      const { content } = matter(contentMd);
+      contentMd = content;
+    } catch {
+      // If parsing fails, use original content
+    }
+  }
+  
   return {
     ...spec,
+    contentMd,
     tags: spec.tags ? (typeof spec.tags === 'string' ? JSON.parse(spec.tags) : spec.tags) : null,
   };
 }
@@ -112,55 +139,90 @@ function countSubSpecs(specDirPath: string): number {
 
 /**
  * Get all specs (uses filesystem by default, database if projectId provided)
+ * Returns lightweight specs without contentMd for list views
  */
-export async function getSpecs(projectId?: string): Promise<ParsedSpec[]> {
+export async function getSpecs(projectId?: string): Promise<LightweightSpec[]> {
   const specs = await specsService.getAllSpecs(projectId);
-  return specs.map(parseSpecTags);
+  return specs.map(spec => toLightweightSpec(parseSpecTags(spec)));
 }
 
 /**
  * Get all specs with sub-spec count (for sidebar)
+ * Returns lightweight specs without contentMd
  */
-export async function getSpecsWithSubSpecCount(projectId?: string): Promise<(ParsedSpec & { subSpecsCount: number })[]> {
+export async function getSpecsWithSubSpecCount(projectId?: string): Promise<(LightweightSpec & { 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 => ({ ...toLightweightSpec(parseSpecTags(spec)), subSpecsCount: 0 }));
   }
   
   return specs.map(spec => {
     const specDirPath = buildSpecDirPath(spec.filePath);
     const subSpecsCount = countSubSpecs(specDirPath);
-    return { ...parseSpecTags(spec), subSpecsCount };
+    return { ...toLightweightSpec(parseSpecTags(spec)), subSpecsCount };
   });
 }
 
+/**
+ * Extract relationships from spec content (contentMd contains frontmatter)
+ * Used for multi-project mode where we can't read from filesystem
+ */
+function getRelationshipsFromContent(contentMd: string): SpecRelationships {
+  try {
+    const { data } = matter(contentMd);
+    const dependsOn = normalizeRelationshipList(data?.depends_on ?? data?.dependsOn);
+    return {
+      dependsOn,
+      requiredBy: [],
+    };
+  } catch (error) {
+    console.warn('Unable to parse spec relationships from content', error);
+    return { dependsOn: [], requiredBy: [] };
+  }
+}
+
 /**
  * Get all specs with sub-spec count and relationships (for comprehensive list view)
+ * Builds the full dependency graph to compute requiredBy (reverse dependencies)
+ * Returns lightweight specs without contentMd
  */
-export async function getSpecsWithMetadata(projectId?: string): Promise<(ParsedSpec & { subSpecsCount: number; relationships: SpecRelationships })[]> {
+export async function getSpecsWithMetadata(projectId?: string): Promise<(LightweightSpec & { subSpecsCount: number; relationships: SpecRelationships })[]> {
   const specs = await specsService.getAllSpecs(projectId);
   
-  // Only count sub-specs and relationships for filesystem mode
-  if (projectId) {
-    return specs.map(spec => ({ 
-      ...parseSpecTags(spec), 
-      subSpecsCount: 0,
-      relationships: { dependsOn: [], related: [] }
-    }));
+  // First pass: collect all dependsOn relationships
+  const specRelationshipsMap = new Map<string, { dependsOn: string[]; requiredBy: string[] }>();
+  
+  for (const spec of specs) {
+    // For multi-project mode, extract from contentMd; for filesystem mode, read from disk
+    const { dependsOn } = projectId 
+      ? getRelationshipsFromContent(spec.contentMd)
+      : getFilesystemRelationships(buildSpecDirPath(spec.filePath));
+    specRelationshipsMap.set(spec.specName, { dependsOn, requiredBy: [] });
+  }
+  
+  // Second pass: compute requiredBy (reverse lookup)
+  for (const [specName, rels] of specRelationshipsMap.entries()) {
+    for (const dep of rels.dependsOn) {
+      const depRels = specRelationshipsMap.get(dep);
+      if (depRels) {
+        depRels.requiredBy.push(specName);
+      }
+    }
   }
   
   return specs.map(spec => {
-    const specDirPath = buildSpecDirPath(spec.filePath);
-    const subSpecsCount = countSubSpecs(specDirPath);
-    const relationships = getFilesystemRelationships(specDirPath);
-    return { ...parseSpecTags(spec), subSpecsCount, relationships };
+    // Sub-specs count only available in filesystem mode
+    const subSpecsCount = projectId ? 0 : countSubSpecs(buildSpecDirPath(spec.filePath));
+    const relationships = specRelationshipsMap.get(spec.specName) || { dependsOn: [], requiredBy: [] };
+    return { ...toLightweightSpec(parseSpecTags(spec)), subSpecsCount, relationships };
   });
 }
 
 /**
  * Get a spec by ID (number or UUID)
+ * Computes requiredBy by scanning all specs for reverse dependencies
  */
 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);
@@ -173,30 +235,61 @@ export async function getSpecById(id: string, projectId?: string): Promise<(Pars
   if (!projectId) {
     const specDirPath = buildSpecDirPath(spec.filePath);
     const subSpecs = detectSubSpecs(specDirPath);
-    const relationships = getFilesystemRelationships(specDirPath);
-    return { ...parsedSpec, subSpecs, relationships };
+    const { dependsOn } = getFilesystemRelationships(specDirPath);
+    
+    // Compute requiredBy by scanning all specs
+    const allSpecs = await specsService.getAllSpecs();
+    const requiredBy: string[] = [];
+    
+    for (const otherSpec of allSpecs) {
+      if (otherSpec.specName === spec.specName) continue;
+      const otherSpecDirPath = buildSpecDirPath(otherSpec.filePath);
+      const otherRels = getFilesystemRelationships(otherSpecDirPath);
+      if (otherRels.dependsOn.includes(spec.specName)) {
+        requiredBy.push(otherSpec.specName);
+      }
+    }
+    
+    return { ...parsedSpec, subSpecs, relationships: { dependsOn, requiredBy } };
   }
 
-  return parsedSpec;
+  // Multi-project mode: extract relationships from spec content and compute requiredBy
+  const { dependsOn } = getRelationshipsFromContent(spec.contentMd);
+  
+  // Compute requiredBy by scanning all specs in the project
+  const allSpecs = await specsService.getAllSpecs(projectId);
+  const requiredBy: string[] = [];
+  
+  for (const otherSpec of allSpecs) {
+    if (otherSpec.specName === spec.specName) continue;
+    const otherRels = getRelationshipsFromContent(otherSpec.contentMd);
+    if (otherRels.dependsOn.includes(spec.specName)) {
+      requiredBy.push(otherSpec.specName);
+    }
+  }
+
+  return { ...parsedSpec, relationships: { dependsOn, requiredBy } };
 }
 
 /**
  * Get specs by status
+ * Returns lightweight specs without contentMd
  */
 export async function getSpecsByStatus(
   status: 'planned' | 'in-progress' | 'complete' | 'archived',
   projectId?: string
-): Promise<ParsedSpec[]> {
+): Promise<LightweightSpec[]> {
   const specs = await specsService.getSpecsByStatus(status, projectId);
-  return specs.map(parseSpecTags);
+  return specs.map(spec => toLightweightSpec(parseSpecTags(spec)));
 }
 
 /**
  * Search specs
+ * Returns lightweight specs without contentMd (search happens server-side)
  */
-export async function searchSpecs(query: string, projectId?: string): Promise<ParsedSpec[]> {
+export async function searchSpecs(query: string, projectId?: string): Promise<LightweightSpec[]> {
   const specs = await specsService.searchSpecs(query, projectId);
-  return specs.map(parseSpecTags);
+  return specs.map(spec => toLightweightSpec(parseSpecTags(spec)));
 }
 
 /**
@@ -238,6 +331,26 @@ export async function getStats(projectId?: string): Promise<StatsResult> {
   };
 }
 
+/**
+ * Get all unique tags from specs in a project
+ * Returns sorted array of unique tag strings
+ */
+export async function getAllTags(projectId?: string): Promise<string[]> {
+  const specs = await specsService.getAllSpecs(projectId);
+  const tagSet = new Set<string>();
+  
+  for (const spec of specs) {
+    const parsedSpec = parseSpecTags(spec);
+    if (parsedSpec.tags && Array.isArray(parsedSpec.tags)) {
+      for (const tag of parsedSpec.tags) {
+        tagSet.add(tag);
+      }
+    }
+  }
+  
+  return Array.from(tagSet).sort();
+}
+
 // ============================================================================
 // Project Context Functions (Spec 131)
 // ============================================================================
@@ -290,8 +403,8 @@ function readContextFile(filePath: string, projectRoot: string): ContextFile | n
 /**
  * Get agent instruction files (AGENTS.md, GEMINI.md, etc.)
  */
-export async function getAgentInstructions(): Promise<ContextFile[]> {
-  const projectRoot = getProjectRootDir();
+export async function getAgentInstructions(projectRootOverride?: string): Promise<ContextFile[]> {
+  const projectRoot = projectRootOverride || getProjectRootDir();
   const files: ContextFile[] = [];
   
   // Primary agent instruction files in root
@@ -336,8 +449,8 @@ export async function getAgentInstructions(): Promise<ContextFile[]> {
 /**
  * Get LeanSpec configuration
  */
-export async function getProjectConfig(): Promise<{ file: ContextFile | null; parsed: LeanSpecConfig | null }> {
-  const projectRoot = getProjectRootDir();
+export async function getProjectConfig(projectRootOverride?: string): Promise<{ file: ContextFile | null; parsed: LeanSpecConfig | null }> {
+  const projectRoot = projectRootOverride || getProjectRootDir();
   const configPath = join(projectRoot, '.lean-spec', 'config.json');
   
   const file = readContextFile(configPath, projectRoot);
@@ -357,8 +470,8 @@ export async function getProjectConfig(): Promise<{ file: ContextFile | null; pa
 /**
  * Get project documentation files (README, CONTRIBUTING, etc.)
  */
-export async function getProjectDocs(): Promise<ContextFile[]> {
-  const projectRoot = getProjectRootDir();
+export async function getProjectDocs(projectRootOverride?: string): Promise<ContextFile[]> {
+  const projectRoot = projectRootOverride || getProjectRootDir();
   const files: ContextFile[] = [];
   
   const docFiles = [
@@ -378,12 +491,12 @@ export async function getProjectDocs(): Promise<ContextFile[]> {
 /**
  * Get complete project context
  */
-export async function getProjectContext(): Promise<ProjectContext> {
-  const projectRoot = getProjectRootDir();
+export async function getProjectContext(projectRootOverride?: string): Promise<ProjectContext> {
+  const projectRoot = projectRootOverride || getProjectRootDir();
   const [agentInstructions, config, projectDocs] = await Promise.all([
-    getAgentInstructions(),
-    getProjectConfig(),
-    getProjectDocs(),
+    getAgentInstructions(projectRoot),
+    getProjectConfig(projectRoot),
+    getProjectDocs(projectRoot),
   ]);
   
   // Calculate total tokens
@@ -406,3 +519,80 @@ export async function getProjectContext(): Promise<ProjectContext> {
     projectRoot,
   };
 }
+
+/**
+ * Dependency graph types for visualization
+ */
+export interface DependencyGraph {
+  nodes: Array<{
+    id: string;
+    name: string;
+    number: number;
+    status: string;
+    priority: string;
+    tags: string[];
+  }>;
+  edges: Array<{
+    source: string;
+    target: string;
+    type: 'dependsOn';
+  }>;
+}
+
+/**
+ * Build dependency graph for visualization
+ * Called directly from server components to avoid fetch issues with custom ports
+ */
+export async function getDependencyGraph(projectId?: string): Promise<DependencyGraph> {
+  const specs = await getSpecsWithMetadata(projectId);
+  
+  const nodes = specs
+    .filter(spec => spec.specNumber !== null)
+    .map(spec => ({
+      id: spec.id,
+      name: spec.title || spec.specName || `Spec ${spec.specNumber}`,
+      number: spec.specNumber!,
+      status: spec.status || 'planned',
+      priority: spec.priority || 'medium',
+      tags: spec.tags || [],
+    }));
+
+  const edges: DependencyGraph['edges'] = [];
+  const specIdByFolder = new Map<string, string>();
+  
+  specs.forEach(spec => {
+    if (spec.specNumber !== null) {
+      const folderName = spec.filePath
+        .replace(/^specs\//, '')
+        .replace(/\/README\.md$/, '');
+      specIdByFolder.set(folderName, spec.id);
+      
+      const paddedNumber = spec.specNumber.toString().padStart(3, '0');
+      specIdByFolder.set(paddedNumber, spec.id);
+      specIdByFolder.set(spec.specNumber.toString(), spec.id);
+    }
+  });
+
+  specs.forEach(spec => {
+    if (!spec.specNumber) return;
+    
+    // Only process dependsOn relationships (no related)
+    spec.relationships.dependsOn.forEach(dep => {
+      const depTrimmed = dep.trim();
+      const match = depTrimmed.match(/^(\d+)/);
+      const targetId = match 
+        ? specIdByFolder.get(match[1]) || specIdByFolder.get(match[1].padStart(3, '0'))
+        : specIdByFolder.get(depTrimmed);
+      
+      if (targetId && targetId !== spec.id) {
+        edges.push({
+          source: targetId,
+          target: spec.id,
+          type: 'dependsOn',
+        });
+      }
+    });
+  });
+
+  return { nodes, edges };
+}

package/.next/standalone/packages/ui/src/lib/dependency-graph.ts

@@ -7,7 +7,6 @@ export interface SpecFrontmatter {
   status: string;
   created: string;
   depends_on?: string[];
-  related?: string[];
   priority?: string;
   tags?: string[];
   assignee?: string;
@@ -24,14 +23,12 @@ export interface SpecInfo {
 interface DependencyNode {
   dependsOn: Set<string>;
   requiredBy: Set<string>;
-  related: Set<string>;
 }
 
 export interface CompleteDependencyGraph {
   current: SpecInfo;
   dependsOn: SpecInfo[];
   requiredBy: SpecInfo[];
-  related: SpecInfo[];
 }
 
 /**
@@ -54,7 +51,6 @@ export class SpecDependencyGraph {
       this.graph.set(spec.path, {
         dependsOn: new Set(spec.frontmatter.depends_on || []),
         requiredBy: new Set(),
-        related: new Set(spec.frontmatter.related || []),
       });
     }
 
@@ -67,14 +63,6 @@ export class SpecDependencyGraph {
           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);
-        }
-      }
     }
   }
 
@@ -93,7 +81,6 @@ export class SpecDependencyGraph {
       current: spec,
       dependsOn: this.getSpecsByPaths(Array.from(node.dependsOn)),
       requiredBy: this.getSpecsByPaths(Array.from(node.requiredBy)),
-      related: this.getSpecsByPaths(Array.from(node.related)),
     };
   }
 

package/.next/standalone/packages/ui/src/lib/projects/registry.ts

@@ -90,7 +90,7 @@ export class ProjectRegistry {
 
     const yamlContent = yaml.dump(serializable, {
       indent: 2,
-      lineWidth: 100,
+      lineWidth: -1, // Disable line wrapping to prevent YAML corruption
     });
 
     await fs.writeFile(PROJECTS_CONFIG_FILE, yamlContent, 'utf-8');

package/.next/standalone/packages/ui/src/lib/specs/sources/multi-project-source.ts

@@ -227,10 +227,26 @@ export class MultiProjectFilesystemSource implements SpecSource {
     try {
       const { data: frontmatter, content: markdown } = matter(content);
 
+      // Validate frontmatter has required status field
+      if (!frontmatter || !frontmatter.status) {
+        return null;
+      }
+
       // Extract title from markdown (first h1)
       const titleMatch = markdown.match(/^#\s+(.+)$/m);
       const title = titleMatch ? titleMatch[1] : frontmatter.title || specName;
 
+      // Handle both created_at/created and updated_at/updated aliases
+      const createdValue = frontmatter.created_at ?? frontmatter.created;
+      const updatedValue = frontmatter.updated_at ?? frontmatter.updated;
+      const completedValue = frontmatter.completed_at ?? frontmatter.completed;
+
+      const toDate = (value: unknown): Date | null => {
+        if (!value) return null;
+        const parsed = new Date(value as string | number | Date);
+        return isNaN(parsed.getTime()) ? null : parsed;
+      };
+
       return {
         id: `${projectId}:${specNum.toString().padStart(3, '0')}`,
         projectId,
@@ -238,14 +254,14 @@ export class MultiProjectFilesystemSource implements SpecSource {
         specName,
         title,
         status: frontmatter.status,
-        priority: frontmatter.priority,
+        priority: frontmatter.priority || null,
         tags: frontmatter.tags ? JSON.stringify(frontmatter.tags) : null,
         assignee: frontmatter.assignee || null,
-        contentMd: content,
+        contentMd: content, // Keep full content with frontmatter for relationship extraction
         contentHtml: null,
-        createdAt: frontmatter.created_at ? new Date(frontmatter.created_at) : null,
-        updatedAt: frontmatter.updated_at ? new Date(frontmatter.updated_at) : null,
-        completedAt: frontmatter.completed_at ? new Date(frontmatter.completed_at) : null,
+        createdAt: toDate(createdValue),
+        updatedAt: toDate(updatedValue),
+        completedAt: toDate(completedValue),
         filePath,
         githubUrl: null,
         syncedAt: new Date(),

package/.next/standalone/packages/ui/src/types/specs.ts

@@ -1,10 +1,9 @@
-import type { ParsedSpec } from '@/lib/db/service-queries';
+import type { ParsedSpec, LightweightSpec } from '@/lib/db/service-queries';
 import type { SubSpec } from '@/lib/sub-specs';
 
 export interface SpecRelationships {
   dependsOn: string[];
-  related: string[];
-  requiredBy?: string[]; // Downstream dependents (specs that depend on this one)
+  requiredBy: string[]; // Downstream dependents (specs that depend on this one)
 }
 
 export type SpecWithMetadata = ParsedSpec & {
@@ -12,7 +11,10 @@ export type SpecWithMetadata = ParsedSpec & {
   relationships?: SpecRelationships;
 };
 
-export type SidebarSpec = Pick<SpecWithMetadata, 'id' | 'specNumber' | 'title' | 'specName' | 'status' | 'priority' | 'contentMd' | 'updatedAt'> & {
+/**
+ * Lightweight spec type for sidebar (no contentMd for performance)
+ */
+export type SidebarSpec = Pick<LightweightSpec, 'id' | 'specNumber' | 'title' | 'specName' | 'status' | 'priority' | 'updatedAt'> & {
   tags: string[] | null;
   subSpecsCount?: number;
 };