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

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/registry.ts

@@ -173,11 +173,11 @@ export class ProjectRegistry {
         name,
         description,
       };
-    } catch (error: any) {
+    } catch (error) {
       return {
         isValid: false,
         path: projectPath,
-        error: error.message || 'Unknown error',
+        error: error instanceof Error ? error.message : 'Unknown error',
       };
     }
   }
@@ -244,11 +244,51 @@ export class ProjectRegistry {
     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;
   }
 
@@ -309,6 +349,7 @@ export class ProjectRegistry {
   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;
@@ -330,7 +371,7 @@ export class ProjectRegistry {
           const fullPath = path.join(dir, entry.name);
           
           // Check if this directory is a LeanSpec project
-          const validation = await projectRegistry.validateProject(fullPath);
+          const validation = await self.validateProject(fullPath);
           if (validation.isValid) {
             discovered.push(validation);
           } else {
@@ -347,6 +388,39 @@ export class ProjectRegistry {
     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
    */

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

@@ -26,7 +26,7 @@ export class MultiProjectFilesystemSource implements SpecSource {
    */
   async getAllSpecs(projectId?: string): Promise<Spec[]> {
     if (!projectId) {
-      throw new Error('projectId is required for multi-project mode');
+      return [];
     }
 
     const cacheKey = `project:${projectId}:all`;
@@ -56,7 +56,7 @@ export class MultiProjectFilesystemSource implements SpecSource {
    */
   async getSpec(specPath: string, projectId?: string): Promise<Spec | null> {
     if (!projectId) {
-      throw new Error('projectId is required for multi-project mode');
+      return null;
     }
 
     const cacheKey = `project:${projectId}:spec:${specPath}`;
@@ -237,8 +237,8 @@ export class MultiProjectFilesystemSource implements SpecSource {
         specNumber: specNum,
         specName,
         title,
-        status: frontmatter.status as any,
-        priority: frontmatter.priority as any,
+        status: frontmatter.status,
+        priority: frontmatter.priority,
         tags: frontmatter.tags ? JSON.stringify(frontmatter.tags) : null,
         assignee: frontmatter.assignee || null,
         contentMd: content,