@leanspec/ui 0.2.5 → 0.2.6-dev.20251125015611

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

@@ -136,6 +136,29 @@ export async function getSpecsWithSubSpecCount(projectId?: string): Promise<(Par
   });
 }
 
+/**
+ * Get all specs with sub-spec count and relationships (for comprehensive list view)
+ */
+export async function getSpecsWithMetadata(projectId?: string): Promise<(ParsedSpec & { 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: [] }
+    }));
+  }
+  
+  return specs.map(spec => {
+    const specDirPath = buildSpecDirPath(spec.filePath);
+    const subSpecsCount = countSubSpecs(specDirPath);
+    const relationships = getFilesystemRelationships(specDirPath);
+    return { ...parseSpecTags(spec), subSpecsCount, relationships };
+  });
+}
+
 /**
  * Get a spec by ID (number or UUID)
  */

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

@@ -0,0 +1,7 @@
+/**
+ * Local projects module
+ * Manages filesystem-based project switching
+ */
+
+export * from './types';
+export * from './registry';

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

@@ -0,0 +1,467 @@
+/**
+ * Project registry for local filesystem projects
+ * Manages discovery, storage, and retrieval of local LeanSpec projects
+ */
+
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
+import yaml from 'js-yaml';
+import type { LocalProject, ProjectsConfig, ProjectValidation } from './types';
+
+const PROJECTS_CONFIG_FILE = path.join(homedir(), '.lean-spec', 'projects.yaml');
+
+/**
+ * Project Registry - manages local filesystem projects
+ */
+export class ProjectRegistry {
+  private config: ProjectsConfig | null = null;
+
+  /**
+   * Generate a unique ID for a project based on its path
+   */
+  private generateProjectId(projectPath: string): string {
+    return createHash('sha256')
+      .update(projectPath)
+      .digest('hex')
+      .substring(0, 12);
+  }
+
+  /**
+   * Load projects configuration from disk
+   */
+  private async loadConfig(): Promise<ProjectsConfig> {
+    if (this.config) {
+      return this.config;
+    }
+
+    try {
+      const configDir = path.dirname(PROJECTS_CONFIG_FILE);
+      await fs.mkdir(configDir, { recursive: true });
+
+      const fileContent = await fs.readFile(PROJECTS_CONFIG_FILE, 'utf-8');
+      const parsed = yaml.load(fileContent) as any;
+      
+      // Convert date strings back to Date objects
+      const projects = (parsed.projects || []).map((p: any) => ({
+        ...p,
+        lastAccessed: p.lastAccessed ? new Date(p.lastAccessed) : new Date(),
+      }));
+
+      this.config = {
+        projects,
+        recentProjects: parsed.recentProjects || [],
+      };
+    } catch (error: any) {
+      if (error.code === 'ENOENT') {
+        // File doesn't exist, create empty config
+        this.config = {
+          projects: [],
+          recentProjects: [],
+        };
+      } else {
+        throw error;
+      }
+    }
+
+    return this.config;
+  }
+
+  /**
+   * Save projects configuration to disk
+   */
+  private async saveConfig(): Promise<void> {
+    if (!this.config) {
+      return;
+    }
+
+    const configDir = path.dirname(PROJECTS_CONFIG_FILE);
+    await fs.mkdir(configDir, { recursive: true });
+
+    // Convert Date objects to ISO strings for serialization
+    const serializable = {
+      projects: this.config.projects.map((p) => ({
+        ...p,
+        lastAccessed: p.lastAccessed.toISOString(),
+      })),
+      recentProjects: this.config.recentProjects,
+    };
+
+    const yamlContent = yaml.dump(serializable, {
+      indent: 2,
+      lineWidth: 100,
+    });
+
+    await fs.writeFile(PROJECTS_CONFIG_FILE, yamlContent, 'utf-8');
+  }
+
+  /**
+   * Validate a project path and extract metadata
+   */
+  async validateProject(projectPath: string): Promise<ProjectValidation> {
+    try {
+      const normalizedPath = path.resolve(projectPath);
+      
+      // Check if path exists
+      const stats = await fs.stat(normalizedPath);
+      if (!stats.isDirectory()) {
+        return {
+          isValid: false,
+          path: normalizedPath,
+          error: 'Path is not a directory',
+        };
+      }
+
+      // Look for .lean-spec directory or specs directory
+      let specsDir: string | undefined;
+      const leanSpecDir = path.join(normalizedPath, '.lean-spec');
+      const specsOnlyDir = path.join(normalizedPath, 'specs');
+      
+      try {
+        await fs.access(leanSpecDir);
+        // If .lean-spec exists, check for specs inside or alongside
+        const specsInLeanSpec = path.join(leanSpecDir, '../specs');
+        try {
+          await fs.access(specsInLeanSpec);
+          specsDir = specsInLeanSpec;
+        } catch {
+          specsDir = specsOnlyDir;
+        }
+      } catch {
+        // No .lean-spec, check for specs directory
+        try {
+          await fs.access(specsOnlyDir);
+          specsDir = specsOnlyDir;
+        } catch {
+          return {
+            isValid: false,
+            path: normalizedPath,
+            error: 'No .lean-spec directory or specs directory found',
+          };
+        }
+      }
+
+      // Try to read project name and description from various sources
+      let name = path.basename(normalizedPath);
+      let description: string | undefined;
+
+      // Try leanspec.yaml
+      try {
+        const leanspecYaml = path.join(normalizedPath, 'leanspec.yaml');
+        const content = await fs.readFile(leanspecYaml, 'utf-8');
+        const config = yaml.load(content) as any;
+        if (config.name) name = config.name;
+        if (config.description) description = config.description;
+      } catch {
+        // Try package.json
+        try {
+          const packageJson = path.join(normalizedPath, 'package.json');
+          const content = await fs.readFile(packageJson, 'utf-8');
+          const pkg = JSON.parse(content);
+          if (pkg.name) name = pkg.name;
+          if (pkg.description) description = pkg.description;
+        } catch {
+          // Use directory name as fallback
+        }
+      }
+
+      return {
+        isValid: true,
+        path: normalizedPath,
+        specsDir: path.resolve(specsDir),
+        name,
+        description,
+      };
+    } catch (error) {
+      return {
+        isValid: false,
+        path: projectPath,
+        error: error instanceof Error ? error.message : 'Unknown error',
+      };
+    }
+  }
+
+  /**
+   * Add a project to the registry
+   */
+  async addProject(projectPath: string, options?: { favorite?: boolean; color?: string }): Promise<LocalProject> {
+    const validation = await this.validateProject(projectPath);
+    
+    if (!validation.isValid) {
+      throw new Error(`Invalid project: ${validation.error}`);
+    }
+
+    const config = await this.loadConfig();
+    const projectId = this.generateProjectId(validation.path);
+    
+    // Check if project already exists
+    const existingIndex = config.projects.findIndex((p) => p.id === projectId);
+    
+    const project: LocalProject = {
+      id: projectId,
+      name: validation.name!,
+      path: validation.path,
+      specsDir: validation.specsDir!,
+      lastAccessed: new Date(),
+      favorite: options?.favorite || false,
+      color: options?.color,
+      description: validation.description,
+    };
+
+    if (existingIndex >= 0) {
+      // Update existing project
+      config.projects[existingIndex] = project;
+    } else {
+      // Add new project
+      config.projects.push(project);
+    }
+
+    // Update recent projects
+    this.updateRecentProjects(config, projectId);
+
+    await this.saveConfig();
+    return project;
+  }
+
+  /**
+   * Remove a project from the registry
+   */
+  async removeProject(projectId: string): Promise<void> {
+    const config = await this.loadConfig();
+    
+    config.projects = config.projects.filter((p) => p.id !== projectId);
+    config.recentProjects = config.recentProjects.filter((id) => id !== projectId);
+    
+    await this.saveConfig();
+  }
+
+  /**
+   * Get a project by ID
+   */
+  async getProject(projectId: string): Promise<LocalProject | null> {
+    const config = await this.loadConfig();
+    return config.projects.find((p) => p.id === projectId) || null;
+  }
+
+  /**
+   * Find the closest project root with .lean-spec directory
+   */
+  private async findProjectRoot(startDir: string): Promise<string | null> {
+    let currentDir = path.resolve(startDir);
+    const { root } = path.parse(currentDir);
+
+    while (true) {
+      const leanSpecDir = path.join(currentDir, '.lean-spec');
+      try {
+        await fs.access(leanSpecDir);
+        return currentDir;
+      } catch {
+        // Not found
+      }
+
+      if (currentDir === root) {
+        break;
+      }
+      currentDir = path.dirname(currentDir);
+    }
+    
+    return null;
+  }
+
+  /**
+   * Get all projects
+   */
+  async getProjects(): Promise<LocalProject[]> {
+    const config = await this.loadConfig();
+
+    // Auto-discover if no projects
+    if (config.projects.length === 0) {
+      const projectRoot = await this.findProjectRoot(process.cwd());
+      if (projectRoot) {
+        try {
+          const project = await this.addProject(projectRoot);
+          return [project];
+        } catch (e) {
+          // Ignore error if auto-add fails
+          console.warn('Failed to auto-add default project:', e);
+        }
+      }
+    }
+
+    return config.projects;
+  }
+
+  /**
+   * Update project lastAccessed timestamp and add to recent projects
+   */
+  async touchProject(projectId: string): Promise<void> {
+    const config = await this.loadConfig();
+    
+    const project = config.projects.find((p) => p.id === projectId);
+    if (!project) {
+      return;
+    }
+
+    project.lastAccessed = new Date();
+    this.updateRecentProjects(config, projectId);
+    
+    await this.saveConfig();
+  }
+
+  /**
+   * Toggle favorite status
+   */
+  async toggleFavorite(projectId: string): Promise<boolean> {
+    const config = await this.loadConfig();
+    
+    const project = config.projects.find((p) => p.id === projectId);
+    if (!project) {
+      throw new Error('Project not found');
+    }
+
+    project.favorite = !project.favorite;
+    await this.saveConfig();
+    
+    return project.favorite;
+  }
+
+  /**
+   * Update project metadata
+   */
+  async updateProject(projectId: string, updates: Partial<Pick<LocalProject, 'name' | 'color' | 'description'>>): Promise<LocalProject> {
+    const config = await this.loadConfig();
+    
+    const project = config.projects.find((p) => p.id === projectId);
+    if (!project) {
+      throw new Error('Project not found');
+    }
+
+    Object.assign(project, updates);
+    await this.saveConfig();
+    
+    return project;
+  }
+
+  /**
+   * Discover projects in a directory tree
+   */
+  async discoverProjects(rootDir: string, maxDepth: number = 3): Promise<ProjectValidation[]> {
+    const discovered: ProjectValidation[] = [];
+    
+    const self = this;
+    async function scan(dir: string, depth: number) {
+      if (depth > maxDepth) {
+        return;
+      }
+
+      try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        
+        for (const entry of entries) {
+          if (!entry.isDirectory()) {
+            continue;
+          }
+
+          // Skip common ignore patterns
+          if (entry.name === 'node_modules' || entry.name === '.git' || entry.name.startsWith('.')) {
+            continue;
+          }
+
+          const fullPath = path.join(dir, entry.name);
+          
+          // Check if this directory is a LeanSpec project
+          const validation = await self.validateProject(fullPath);
+          if (validation.isValid) {
+            discovered.push(validation);
+          } else {
+            // Recurse into subdirectories
+            await scan(fullPath, depth + 1);
+          }
+        }
+      } catch (error) {
+        // Skip directories we can't read
+      }
+    }
+
+    await scan(rootDir, 0);
+    return discovered;
+  }
+
+  /**
+   * List directories in a given path
+   */
+  async listDirectory(dirPath: string = homedir()): Promise<{ name: string; path: string; isDirectory: boolean }[]> {
+    try {
+      const normalizedPath = path.resolve(dirPath);
+      const entries = await fs.readdir(normalizedPath, { withFileTypes: true });
+      
+      const items = entries
+        .filter(entry => entry.isDirectory() && !entry.name.startsWith('.'))
+        .map(entry => ({
+          name: entry.name,
+          path: path.join(normalizedPath, entry.name),
+          isDirectory: true
+        }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+
+      // Add parent directory entry if not at root
+      const parentDir = path.dirname(normalizedPath);
+      if (parentDir !== normalizedPath) {
+        items.unshift({
+          name: '..',
+          path: parentDir,
+          isDirectory: true
+        });
+      }
+
+      return items;
+    } catch (error: any) {
+      throw new Error(`Failed to list directory: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get recent projects
+   */
+  async getRecentProjects(limit: number = 10): Promise<LocalProject[]> {
+    const config = await this.loadConfig();
+    
+    return config.recentProjects
+      .slice(0, limit)
+      .map((id) => config.projects.find((p) => p.id === id))
+      .filter((p): p is LocalProject => p !== undefined);
+  }
+
+  /**
+   * Get favorite projects
+   */
+  async getFavoriteProjects(): Promise<LocalProject[]> {
+    const config = await this.loadConfig();
+    return config.projects.filter((p) => p.favorite);
+  }
+
+  /**
+   * Update recent projects list
+   */
+  private updateRecentProjects(config: ProjectsConfig, projectId: string): void {
+    // Remove if already in list
+    config.recentProjects = config.recentProjects.filter((id) => id !== projectId);
+    
+    // Add to front
+    config.recentProjects.unshift(projectId);
+    
+    // Keep only last 10
+    config.recentProjects = config.recentProjects.slice(0, 10);
+  }
+
+  /**
+   * Invalidate cached config
+   */
+  invalidateCache(): void {
+    this.config = null;
+  }
+}
+
+// Singleton instance
+export const projectRegistry = new ProjectRegistry();

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

@@ -0,0 +1,37 @@
+/**
+ * Types for local multi-project support
+ */
+
+/**
+ * Local project metadata
+ */
+export interface LocalProject {
+  id: string;              // Unique identifier (hash of path)
+  name: string;            // Display name (from config or folder name)
+  path: string;            // Absolute path to project root
+  specsDir: string;        // Path to specs/ directory
+  lastAccessed: Date;      // For sorting recent projects
+  favorite: boolean;       // User can pin favorites
+  color?: string;          // Optional color coding
+  description?: string;    // From project README or config
+}
+
+/**
+ * Projects configuration file structure
+ */
+export interface ProjectsConfig {
+  projects: LocalProject[];
+  recentProjects: string[]; // Project IDs in order (max 10)
+}
+
+/**
+ * Project validation result
+ */
+export interface ProjectValidation {
+  isValid: boolean;
+  path: string;
+  specsDir?: string;
+  name?: string;
+  description?: string;
+  error?: string;
+}

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

@@ -4,6 +4,7 @@
  */
 
 import { FilesystemSource } from './sources/filesystem-source';
+import { MultiProjectFilesystemSource } from './sources/multi-project-source';
 import type { SpecSource } from './types';
 import type { Spec } from '../db/schema';
 
@@ -14,10 +15,11 @@ let DatabaseSourceCtor: DatabaseSourceConstructor | null = null;
 /**
  * Service modes
  * - filesystem: Read from local filesystem only (LeanSpec's own specs)
+ * - multi-project: Read from multiple local filesystem projects
  * - database: Read from database only (external repos)
  * - both: Support both modes (route based on projectId)
  */
-type SpecsMode = 'filesystem' | 'database' | 'both';
+type SpecsMode = 'filesystem' | 'multi-project' | 'database' | 'both';
 
 /**
  * Unified specs service
@@ -25,6 +27,7 @@ type SpecsMode = 'filesystem' | 'database' | 'both';
  */
 export class SpecsService {
   private filesystemSource?: FilesystemSource;
+  private multiProjectSource?: MultiProjectFilesystemSource;
   private databaseSource?: SpecSource;
   private mode: SpecsMode;
 
@@ -36,6 +39,10 @@ export class SpecsService {
       this.filesystemSource = new FilesystemSource(specsDir);
     }
 
+    if (this.mode === 'multi-project') {
+      this.multiProjectSource = new MultiProjectFilesystemSource();
+    }
+
     // Don't instantiate database source here - do it lazily
   }
 
@@ -102,6 +109,11 @@ export class SpecsService {
    * Get the appropriate source based on projectId and mode
    */
   private async getSource(projectId?: string): Promise<SpecSource> {
+    // Multi-project mode: use multi-project source
+    if (this.mode === 'multi-project' && this.multiProjectSource) {
+      return this.multiProjectSource;
+    }
+
     // If projectId provided, use database (external repo)
     if (projectId && (this.mode === 'database' || this.mode === 'both')) {
       return await this.getDatabaseSource();

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

@@ -135,11 +135,29 @@ export class FilesystemSource implements SpecSource {
 
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      if (entry.name === 'archived') continue; // Skip archived directory
+
+      // Load archived specs from archived/ directory
+      if (entry.name === 'archived') {
+        const archivedDir = path.join(this.specsDir, 'archived');
+        const archivedEntries = await fs.readdir(archivedDir, { withFileTypes: true });
+        
+        for (const archivedEntry of archivedEntries) {
+          if (!archivedEntry.isDirectory()) continue;
+          
+          if (specPattern.test(archivedEntry.name)) {
+            const specDir = path.join(archivedDir, archivedEntry.name);
+            const spec = await this.loadSpecFromDirectory(specDir, archivedEntry.name, true);
+            if (spec) {
+              specs.push(spec);
+            }
+          }
+        }
+        continue;
+      }
 
       if (specPattern.test(entry.name)) {
         const specDir = path.join(this.specsDir, entry.name);
-        const spec = await this.loadSpecFromDirectory(specDir, entry.name);
+        const spec = await this.loadSpecFromDirectory(specDir, entry.name, false);
         if (spec) {
           specs.push(spec);
         }
@@ -163,12 +181,30 @@ export class FilesystemSource implements SpecSource {
     const entries = await fs.readdir(this.specsDir, { withFileTypes: true });
     const specPattern = new RegExp(`^0*${specNum}-`);
 
+    // Check regular specs
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
+      if (entry.name === 'archived') continue; // Check archived separately
       if (specPattern.test(entry.name)) {
         const specDir = path.join(this.specsDir, entry.name);
-        return await this.loadSpecFromDirectory(specDir, entry.name);
+        return await this.loadSpecFromDirectory(specDir, entry.name, false);
+      }
+    }
+
+    // Check archived specs
+    try {
+      const archivedDir = path.join(this.specsDir, 'archived');
+      const archivedEntries = await fs.readdir(archivedDir, { withFileTypes: true });
+      
+      for (const entry of archivedEntries) {
+        if (!entry.isDirectory()) continue;
+        if (specPattern.test(entry.name)) {
+          const specDir = path.join(archivedDir, entry.name);
+          return await this.loadSpecFromDirectory(specDir, entry.name, true);
+        }
       }
+    } catch {
+      // Archived directory doesn't exist or can't be read
     }
 
     return null;
@@ -177,7 +213,7 @@ export class FilesystemSource implements SpecSource {
   /**
    * Load a spec from a directory
    */
-  private async loadSpecFromDirectory(specDir: string, specName: string): Promise<Spec | null> {
+  private async loadSpecFromDirectory(specDir: string, specName: string, isArchived: boolean = false): Promise<Spec | null> {
     const readmePath = path.join(specDir, 'README.md');
 
     try {
@@ -205,6 +241,10 @@ export class FilesystemSource implements SpecSource {
         return isNaN(parsed.getTime()) ? null : parsed;
       };
 
+      // Build the file path (include "archived/" prefix if archived)
+      const filePathPrefix = isArchived ? 'specs/archived/' : 'specs/';
+      const filePath = `${filePathPrefix}${specName}/README.md`;
+
       // Create a Spec object compatible with the schema
       const spec: Spec = {
         id,
@@ -221,8 +261,8 @@ export class FilesystemSource implements SpecSource {
         createdAt: toDate(createdValue),
         updatedAt: toDate(updatedValue),
         completedAt: toDate(completedValue),
-        filePath: `specs/${specName}/README.md`,
-        githubUrl: `https://github.com/codervisor/lean-spec/tree/main/specs/${specName}/README.md`,
+        filePath,
+        githubUrl: `https://github.com/codervisor/lean-spec/tree/main/${filePath}`,
         syncedAt: new Date(), // Current time for filesystem reads
       };