@leanspec/ui 0.2.8 → 0.2.9-dev.20251205030455

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

@@ -18,6 +18,20 @@ 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'> {
+  const { contentMd, contentHtml, ...rest } = spec;
+  return rest;
+}
+
 const DEFAULT_SPECS_DIR = resolve(process.cwd(), '../../specs');
 
 function getSpecsRootDir(): string {
@@ -37,7 +51,7 @@ function buildSpecDirPath(filePath: string): string {
 
 interface SpecRelationships {
   dependsOn: string[];
-  related: string[];
+  requiredBy: string[];
 }
 function normalizeRelationshipList(value: unknown): string[] {
   if (!value) return [];
@@ -56,14 +70,14 @@ 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: [] };
   }
 }
 
@@ -112,55 +126,79 @@ 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 };
   });
 }
 
 /**
  * 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), 
+      ...toLightweightSpec(parseSpecTags(spec)), 
       subSpecsCount: 0,
-      relationships: { dependsOn: [], related: [] }
+      relationships: { dependsOn: [], requiredBy: [] }
     }));
   }
   
+  // First pass: collect all dependsOn relationships
+  const specRelationshipsMap = new Map<string, { dependsOn: string[]; requiredBy: string[] }>();
+  
+  for (const spec of specs) {
+    const specDirPath = buildSpecDirPath(spec.filePath);
+    const { dependsOn } = getFilesystemRelationships(specDirPath);
+    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 };
+    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,8 +211,22 @@ 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;
@@ -182,21 +234,23 @@ export async function getSpecById(id: string, projectId?: string): Promise<(Pars
 
 /**
  * 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)));
 }
 
 /**
@@ -290,8 +344,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 +390,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 +411,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 +432,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

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/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;
 };