@leanspec/ui 0.2.5-dev.20251120060929 → 0.2.5-dev.20251120072524

package/.next/standalone/packages/ui/src/contexts/project-context.tsx

@@ -0,0 +1,225 @@
+/**
+ * Project Context
+ * Manages the current project state for multi-project mode
+ */
+
+'use client';
+
+import React, { createContext, useContext, useState, useEffect, useCallback } from 'react';
+import type { LocalProject } from '@/lib/projects/types';
+
+interface ProjectContextType {
+  currentProject: LocalProject | null;
+  projects: LocalProject[];
+  recentProjects: LocalProject[];
+  favoriteProjects: LocalProject[];
+  isLoading: boolean;
+  error: string | null;
+  switchProject: (projectId: string) => Promise<void>;
+  addProject: (path: string, options?: { favorite?: boolean; color?: string }) => Promise<LocalProject>;
+  removeProject: (projectId: string) => Promise<void>;
+  toggleFavorite: (projectId: string) => Promise<void>;
+  updateProject: (projectId: string, updates: Partial<Pick<LocalProject, 'name' | 'color' | 'description'>>) => Promise<void>;
+  refreshProjects: () => Promise<void>;
+}
+
+const ProjectContext = createContext<ProjectContextType | null>(null);
+
+export function useProject() {
+  const context = useContext(ProjectContext);
+  if (!context) {
+    throw new Error('useProject must be used within ProjectProvider');
+  }
+  return context;
+}
+
+interface ProjectProviderProps {
+  children: React.ReactNode;
+  initialProjectId?: string;
+}
+
+export function ProjectProvider({ children, initialProjectId }: ProjectProviderProps) {
+  const [currentProject, setCurrentProject] = useState<LocalProject | null>(null);
+  const [projects, setProjects] = useState<LocalProject[]>([]);
+  const [recentProjects, setRecentProjects] = useState<LocalProject[]>([]);
+  const [favoriteProjects, setFavoriteProjects] = useState<LocalProject[]>([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  // Fetch all projects
+  const refreshProjects = useCallback(async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+
+      const response = await fetch('/api/local-projects');
+      if (!response.ok) {
+        throw new Error('Failed to fetch projects');
+      }
+
+      const data = await response.json();
+      setProjects(data.projects || []);
+      setRecentProjects(data.recentProjects || []);
+      setFavoriteProjects(data.favoriteProjects || []);
+
+      // Set current project if not already set
+      if (!currentProject && data.projects.length > 0) {
+        const projectToSet = initialProjectId 
+          ? data.projects.find((p: LocalProject) => p.id === initialProjectId)
+          : data.recentProjects[0] || data.projects[0];
+        
+        if (projectToSet) {
+          setCurrentProject(projectToSet);
+        }
+      }
+    } catch (err: any) {
+      console.error('Error fetching projects:', err);
+      setError(err.message || 'Failed to load projects');
+    } finally {
+      setIsLoading(false);
+    }
+  }, [currentProject, initialProjectId]);
+
+  // Switch to a different project
+  const switchProject = useCallback(async (projectId: string) => {
+    try {
+      const response = await fetch(`/api/local-projects/${projectId}`);
+      if (!response.ok) {
+        throw new Error('Failed to fetch project');
+      }
+
+      const data = await response.json();
+      setCurrentProject(data.project);
+
+      // Refresh recent projects list
+      await refreshProjects();
+    } catch (err: any) {
+      console.error('Error switching project:', err);
+      setError(err.message || 'Failed to switch project');
+      throw err;
+    }
+  }, [refreshProjects]);
+
+  // Add a new project
+  const addProject = useCallback(async (
+    path: string,
+    options?: { favorite?: boolean; color?: string }
+  ): Promise<LocalProject> => {
+    try {
+      const response = await fetch('/api/local-projects', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ path, ...options }),
+      });
+
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(error.details || 'Failed to add project');
+      }
+
+      const data = await response.json();
+      await refreshProjects();
+      return data.project;
+    } catch (err: any) {
+      console.error('Error adding project:', err);
+      setError(err.message || 'Failed to add project');
+      throw err;
+    }
+  }, [refreshProjects]);
+
+  // Remove a project
+  const removeProject = useCallback(async (projectId: string) => {
+    try {
+      const response = await fetch(`/api/local-projects/${projectId}`, {
+        method: 'DELETE',
+      });
+
+      if (!response.ok) {
+        throw new Error('Failed to remove project');
+      }
+
+      // If we removed the current project, switch to another
+      if (currentProject?.id === projectId) {
+        const otherProject = projects.find((p) => p.id !== projectId);
+        setCurrentProject(otherProject || null);
+      }
+
+      await refreshProjects();
+    } catch (err: any) {
+      console.error('Error removing project:', err);
+      setError(err.message || 'Failed to remove project');
+      throw err;
+    }
+  }, [currentProject, projects, refreshProjects]);
+
+  // Toggle favorite status
+  const toggleFavorite = useCallback(async (projectId: string) => {
+    try {
+      const response = await fetch(`/api/local-projects/${projectId}`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ favorite: true }),
+      });
+
+      if (!response.ok) {
+        throw new Error('Failed to toggle favorite');
+      }
+
+      await refreshProjects();
+    } catch (err: any) {
+      console.error('Error toggling favorite:', err);
+      setError(err.message || 'Failed to toggle favorite');
+      throw err;
+    }
+  }, [refreshProjects]);
+
+  // Update project metadata
+  const updateProject = useCallback(async (
+    projectId: string,
+    updates: Partial<Pick<LocalProject, 'name' | 'color' | 'description'>>
+  ) => {
+    try {
+      const response = await fetch(`/api/local-projects/${projectId}`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(updates),
+      });
+
+      if (!response.ok) {
+        throw new Error('Failed to update project');
+      }
+
+      await refreshProjects();
+    } catch (err: any) {
+      console.error('Error updating project:', err);
+      setError(err.message || 'Failed to update project');
+      throw err;
+    }
+  }, [refreshProjects]);
+
+  // Load projects on mount
+  useEffect(() => {
+    refreshProjects();
+  }, []);
+
+  const value: ProjectContextType = {
+    currentProject,
+    projects,
+    recentProjects,
+    favoriteProjects,
+    isLoading,
+    error,
+    switchProject,
+    addProject,
+    removeProject,
+    toggleFavorite,
+    updateProject,
+    refreshProjects,
+  };
+
+  return (
+    <ProjectContext.Provider value={value}>
+      {children}
+    </ProjectContext.Provider>
+  );
+}

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,393 @@
+/**
+ * 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: any) {
+      return {
+        isValid: false,
+        path: projectPath,
+        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;
+  }
+
+  /**
+   * Get all projects
+   */
+  async getProjects(): Promise<LocalProject[]> {
+    const config = await this.loadConfig();
+    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[] = [];
+    
+    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 projectRegistry.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;
+  }
+
+  /**
+   * 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();