@leanspec/ui 0.2.5-dev.20251120070726 → 0.2.5-dev.20251120093243

package/.next/standalone/packages/ui/src/components/ui/popover.tsx

@@ -0,0 +1,31 @@
+"use client"
+
+import * as React from "react"
+import * as PopoverPrimitive from "@radix-ui/react-popover"
+
+import { cn } from "@/lib/utils"
+
+const Popover = PopoverPrimitive.Root
+
+const PopoverTrigger = PopoverPrimitive.Trigger
+
+const PopoverContent = React.forwardRef<
+  React.ElementRef<typeof PopoverPrimitive.Content>,
+  React.ComponentPropsWithoutRef<typeof PopoverPrimitive.Content>
+>(({ className, align = "center", sideOffset = 4, ...props }, ref) => (
+  <PopoverPrimitive.Portal>
+    <PopoverPrimitive.Content
+      ref={ref}
+      align={align}
+      sideOffset={sideOffset}
+      className={cn(
+        "z-50 w-72 rounded-md border bg-popover p-4 text-popover-foreground shadow-md outline-none data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
+        className
+      )}
+      {...props}
+    />
+  </PopoverPrimitive.Portal>
+))
+PopoverContent.displayName = PopoverPrimitive.Content.displayName
+
+export { Popover, PopoverTrigger, PopoverContent }

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

@@ -0,0 +1,229 @@
+/**
+ * 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 {
+  mode: 'multi-project' | 'single-project';
+  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 [mode, setMode] = useState<'multi-project' | 'single-project'>('single-project');
+  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/projects');
+      if (!response.ok) {
+        throw new Error('Failed to fetch projects');
+      }
+
+      const data = await response.json();
+      setMode(data.mode || 'single-project');
+      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/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/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/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/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/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 = {
+    mode,
+    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/db/index.ts

@@ -22,6 +22,9 @@ export function getDb() {
     
     // Create SQLite database connection
     _sqlite = new Database(dbPath);
+
+    // Make sure required tables exist before handing the connection to Drizzle
+    ensureSchema(_sqlite);
     
     // Create Drizzle client
     _db = drizzle(_sqlite, { schema });
@@ -40,3 +43,100 @@ export const db = new Proxy({} as ReturnType<typeof drizzle>, {
     return Reflect.get(realDb as object, prop, receiver);
   }
 });
+
+function ensureSchema(sqlite: Database.Database) {
+  sqlite.pragma('foreign_keys = ON');
+
+  const tableExists = (name: string) => {
+    const row = sqlite.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name = ?"
+    ).get(name);
+    return Boolean(row);
+  };
+
+  const indexExists = (name: string) => {
+    const row = sqlite.prepare(
+      "SELECT name FROM sqlite_master WHERE type='index' AND name = ?"
+    ).get(name);
+    return Boolean(row);
+  };
+
+  if (!tableExists('projects')) {
+    sqlite.exec(`
+      CREATE TABLE IF NOT EXISTS "projects" (
+        "id" TEXT PRIMARY KEY NOT NULL,
+        "github_owner" TEXT NOT NULL,
+        "github_repo" TEXT NOT NULL,
+        "display_name" TEXT,
+        "description" TEXT,
+        "homepage_url" TEXT,
+        "stars" INTEGER DEFAULT 0,
+        "is_public" INTEGER DEFAULT 1,
+        "is_featured" INTEGER DEFAULT 0,
+        "last_synced_at" INTEGER,
+        "created_at" INTEGER NOT NULL,
+        "updated_at" INTEGER NOT NULL
+      );
+    `);
+  }
+
+  if (!tableExists('specs')) {
+    sqlite.exec(`
+      CREATE TABLE IF NOT EXISTS "specs" (
+        "id" TEXT PRIMARY KEY NOT NULL,
+        "project_id" TEXT NOT NULL REFERENCES "projects"("id") ON DELETE CASCADE,
+        "spec_number" INTEGER,
+        "spec_name" TEXT NOT NULL,
+        "title" TEXT,
+        "status" TEXT,
+        "priority" TEXT,
+        "tags" TEXT,
+        "assignee" TEXT,
+        "content_md" TEXT NOT NULL,
+        "content_html" TEXT,
+        "created_at" INTEGER,
+        "updated_at" INTEGER,
+        "completed_at" INTEGER,
+        "file_path" TEXT NOT NULL,
+        "github_url" TEXT,
+        "synced_at" INTEGER NOT NULL
+      );
+    `);
+  }
+
+  if (!tableExists('spec_relationships')) {
+    sqlite.exec(`
+      CREATE TABLE IF NOT EXISTS "spec_relationships" (
+        "id" TEXT PRIMARY KEY NOT NULL,
+        "spec_id" TEXT NOT NULL REFERENCES "specs"("id") ON DELETE CASCADE,
+        "related_spec_id" TEXT NOT NULL REFERENCES "specs"("id") ON DELETE CASCADE,
+        "relationship_type" TEXT NOT NULL,
+        "created_at" INTEGER NOT NULL
+      );
+    `);
+  }
+
+  if (!tableExists('sync_logs')) {
+    sqlite.exec(`
+      CREATE TABLE IF NOT EXISTS "sync_logs" (
+        "id" TEXT PRIMARY KEY NOT NULL,
+        "project_id" TEXT NOT NULL REFERENCES "projects"("id") ON DELETE CASCADE,
+        "status" TEXT NOT NULL,
+        "specs_added" INTEGER DEFAULT 0,
+        "specs_updated" INTEGER DEFAULT 0,
+        "specs_deleted" INTEGER DEFAULT 0,
+        "error_message" TEXT,
+        "started_at" INTEGER NOT NULL,
+        "completed_at" INTEGER,
+        "duration_ms" INTEGER
+      );
+    `);
+  }
+
+  if (!indexExists('unique_spec_number')) {
+    sqlite.exec(`
+      CREATE UNIQUE INDEX IF NOT EXISTS "unique_spec_number"
+      ON "specs" ("project_id", "spec_number");
+    `);
+  }
+}

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';