idea-manager 1.0.1 → 1.1.1

package/next.config.mjs

@@ -1,6 +1,6 @@
 /** @type {import('next').NextConfig} */
 const nextConfig = {
-  serverExternalPackages: ['better-sqlite3'],
+  serverExternalPackages: ['sql.js/dist/sql-asm.js'],
 };
 
 export default nextConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "idea-manager",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "Turn free-form brainstorming into structured task trees with AI-generated prompts. Built-in MCP Server for autonomous AI agent execution. Local-first with SQLite, cross-PC sync via Git.",
   "keywords": [
     "brainstorm",
@@ -48,7 +48,6 @@
     "@dnd-kit/sortable": "^10.0.0",
     "@dnd-kit/utilities": "^3.2.2",
     "@modelcontextprotocol/sdk": "^1.27.1",
-    "better-sqlite3": "^12.6.2",
     "commander": "^14.0.3",
     "nanoid": "^5.1.6",
     "next": "16.1.6",
@@ -57,11 +56,11 @@
     "react-dom": "19.2.3",
     "react-markdown": "^10.1.0",
     "remark-gfm": "^4.0.1",
+    "sql.js": "^1.14.1",
     "tsx": "^4.21.0"
   },
   "devDependencies": {
     "@tailwindcss/postcss": "^4",
-    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^20",
     "@types/react": "^19",
     "@types/react-dom": "^19",

package/src/app/api/projects/[id]/brainstorm/route.ts

@@ -1,11 +1,13 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { getBrainstorm, updateBrainstorm } from '@/lib/db/queries/brainstorms';
 import { getProject } from '@/lib/db/queries/projects';
+import { ensureDb } from '@/lib/db';
 
 export async function GET(
   _request: NextRequest,
   { params }: { params: Promise<{ id: string }> },
 ) {
+  await ensureDb();
   const { id } = await params;
   const project = getProject(id);
   if (!project) {
@@ -20,6 +22,7 @@ export async function PUT(
   request: NextRequest,
   { params }: { params: Promise<{ id: string }> },
 ) {
+  await ensureDb();
   const { id } = await params;
   const body = await request.json();
   const { content } = body;

package/src/app/api/projects/[id]/git-sync/route.ts

@@ -4,6 +4,7 @@ import { execFile } from 'child_process';
 import { existsSync, readdirSync, statSync } from 'fs';
 import path from 'path';
 import type { IGitSyncResult } from '@/types';
+import { ensureDb } from '@/lib/db';
 
 function gitPull(cwd: string): Promise<{ stdout: string; stderr: string }> {
   return new Promise((resolve, reject) => {
@@ -68,6 +69,7 @@ export async function POST(
   _request: NextRequest,
   { params }: { params: Promise<{ id: string }> },
 ) {
+  await ensureDb();
   const { id } = await params;
   const project = getProject(id);
 

package/src/app/api/projects/[id]/route.ts

@@ -1,10 +1,12 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { getProject, updateProject, deleteProject } from '@/lib/db/queries/projects';
+import { ensureDb } from '@/lib/db';
 
 export async function GET(
   _request: NextRequest,
   { params }: { params: Promise<{ id: string }> },
 ) {
+  await ensureDb();
   const { id } = await params;
   const project = getProject(id);
   if (!project) {
@@ -17,6 +19,7 @@ export async function PUT(
   request: NextRequest,
   { params }: { params: Promise<{ id: string }> },
 ) {
+  await ensureDb();
   const { id } = await params;
   const body = await request.json();
   const project = updateProject(id, body);
@@ -30,6 +33,7 @@ export async function DELETE(
   _request: NextRequest,
   { params }: { params: Promise<{ id: string }> },
 ) {
+  await ensureDb();
   const { id } = await params;
   const deleted = deleteProject(id);
   if (!deleted) {

package/src/app/api/projects/[id]/sub-projects/[subId]/route.ts

@@ -1,10 +1,12 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { getSubProject, updateSubProject, deleteSubProject } from '@/lib/db/queries/sub-projects';
+import { ensureDb } from '@/lib/db';
 
 export async function GET(
   _request: NextRequest,
   { params }: { params: Promise<{ id: string; subId: string }> },
 ) {
+  await ensureDb();
   const { subId } = await params;
   const sp = getSubProject(subId);
   if (!sp) {
@@ -17,6 +19,7 @@ export async function PUT(
   request: NextRequest,
   { params }: { params: Promise<{ id: string; subId: string }> },
 ) {
+  await ensureDb();
   const { subId } = await params;
   const body = await request.json();
   const sp = updateSubProject(subId, body);
@@ -30,6 +33,7 @@ export async function DELETE(
   _request: NextRequest,
   { params }: { params: Promise<{ id: string; subId: string }> },
 ) {
+  await ensureDb();
   const { subId } = await params;
   const deleted = deleteSubProject(subId);
   if (!deleted) {

package/src/app/api/projects/[id]/sub-projects/[subId]/tasks/[taskId]/chat/route.ts

@@ -5,11 +5,13 @@ import { getTaskPrompt } from '@/lib/db/queries/task-prompts';
 import { getBrainstorm } from '@/lib/db/queries/brainstorms';
 import { getProject } from '@/lib/db/queries/projects';
 import { runAgent } from '@/lib/ai/client';
+import { ensureDb } from '@/lib/db';
 
 export async function GET(
   _request: NextRequest,
   { params }: { params: Promise<{ id: string; subId: string; taskId: string }> },
 ) {
+  await ensureDb();
   const { taskId } = await params;
   const conversations = getTaskConversations(taskId);
   return NextResponse.json(conversations);
@@ -19,6 +21,7 @@ export async function POST(
   request: NextRequest,
   { params }: { params: Promise<{ id: string; subId: string; taskId: string }> },
 ) {
+  await ensureDb();
   const { id: projectId, taskId } = await params;
   const body = await request.json();
 

package/src/app/api/projects/[id]/sub-projects/[subId]/tasks/[taskId]/prompt/route.ts

@@ -1,10 +1,12 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { getTaskPrompt, upsertTaskPrompt } from '@/lib/db/queries/task-prompts';
+import { ensureDb } from '@/lib/db';
 
 export async function GET(
   _request: NextRequest,
   { params }: { params: Promise<{ id: string; subId: string; taskId: string }> },
 ) {
+  await ensureDb();
   const { taskId } = await params;
   const prompt = getTaskPrompt(taskId);
   return NextResponse.json(prompt ?? { content: '', prompt_type: 'manual' });
@@ -14,6 +16,7 @@ export async function PUT(
   request: NextRequest,
   { params }: { params: Promise<{ id: string; subId: string; taskId: string }> },
 ) {
+  await ensureDb();
   const { taskId } = await params;
   const body = await request.json();
 

package/src/app/api/projects/[id]/sub-projects/[subId]/tasks/[taskId]/route.ts

@@ -1,10 +1,12 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { getTask, updateTask, deleteTask } from '@/lib/db/queries/tasks';
+import { ensureDb } from '@/lib/db';
 
 export async function GET(
   _request: NextRequest,
   { params }: { params: Promise<{ id: string; subId: string; taskId: string }> },
 ) {
+  await ensureDb();
   const { taskId } = await params;
   const task = getTask(taskId);
   if (!task) {
@@ -17,6 +19,7 @@ export async function PUT(
   request: NextRequest,
   { params }: { params: Promise<{ id: string; subId: string; taskId: string }> },
 ) {
+  await ensureDb();
   const { taskId } = await params;
   const body = await request.json();
   const task = updateTask(taskId, body);
@@ -30,6 +33,7 @@ export async function DELETE(
   _request: NextRequest,
   { params }: { params: Promise<{ id: string; subId: string; taskId: string }> },
 ) {
+  await ensureDb();
   const { taskId } = await params;
   const deleted = deleteTask(taskId);
   if (!deleted) {

package/src/app/api/projects/[id]/sub-projects/[subId]/tasks/route.ts

@@ -1,10 +1,12 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { getTasks, createTask } from '@/lib/db/queries/tasks';
+import { ensureDb } from '@/lib/db';
 
 export async function GET(
   _request: NextRequest,
   { params }: { params: Promise<{ id: string; subId: string }> },
 ) {
+  await ensureDb();
   const { subId } = await params;
   const tasks = getTasks(subId);
   return NextResponse.json(tasks);
@@ -14,6 +16,7 @@ export async function POST(
   request: NextRequest,
   { params }: { params: Promise<{ id: string; subId: string }> },
 ) {
+  await ensureDb();
   const { id, subId } = await params;
   const body = await request.json();
 

package/src/app/api/projects/[id]/sub-projects/route.ts

@@ -1,10 +1,12 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { getSubProjectsWithStats, createSubProject, reorderSubProjects } from '@/lib/db/queries/sub-projects';
+import { ensureDb } from '@/lib/db';
 
 export async function GET(
   _request: NextRequest,
   { params }: { params: Promise<{ id: string }> },
 ) {
+  await ensureDb();
   const { id } = await params;
   const subProjects = getSubProjectsWithStats(id);
   return NextResponse.json(subProjects);
@@ -14,6 +16,7 @@ export async function POST(
   request: NextRequest,
   { params }: { params: Promise<{ id: string }> },
 ) {
+  await ensureDb();
   const { id } = await params;
   const body = await request.json();
 
@@ -34,6 +37,7 @@ export async function PUT(
   request: NextRequest,
   { params }: { params: Promise<{ id: string }> },
 ) {
+  await ensureDb();
   const { id } = await params;
   const body = await request.json();
 

package/src/app/api/projects/route.ts

@@ -1,12 +1,15 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { listProjects, createProject } from '@/lib/db/queries/projects';
+import { ensureDb } from '@/lib/db';
 
 export async function GET() {
+  await ensureDb();
   const projects = listProjects();
   return NextResponse.json(projects);
 }
 
 export async function POST(request: NextRequest) {
+  await ensureDb();
   const body = await request.json();
   const { name, description } = body;
 

package/src/cli.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 import { Command } from 'commander';
+import { ensureDb } from './lib/db';
 import { startMcpServer } from './lib/mcp/server';
 import { listProjects, getProject } from './lib/db/queries/projects';
 import { getSubProjects } from './lib/db/queries/sub-projects';
@@ -78,6 +79,7 @@ program
   .command('mcp')
   .description('Start MCP server (stdio mode)')
   .action(async () => {
+    await ensureDb();
     const ctx: McpToolContext = {
       listProjects,
       getProject,
@@ -109,27 +111,46 @@ program
 
 program
   .command('start')
-  .description('Start the web UI (Next.js dev server on port 3456)')
+  .description('Start the web UI on port 3456')
   .option('-p, --port <port>', 'Port number', '3456')
   .action(async (opts) => {
     const port = opts.port;
-    console.log(`\n  IM - Idea Manager v2`);
-    console.log(`  Starting on http://localhost:${port}\n`);
+    const fs = await import('fs');
 
-    // Resolve next CLI directly — avoids .bin symlink issues on Windows
-    // and npm global install hoisting issues
+    // Resolve next CLI
     let nextCli: string;
     try {
       nextCli = require.resolve('next/dist/bin/next', { paths: [PKG_ROOT] });
     } catch {
-      // Fallback: try to find next package manually
       nextCli = path.join(PKG_ROOT, 'node_modules', 'next', 'dist', 'bin', 'next');
     }
 
-    const child = spawn(process.execPath, [nextCli, 'dev', '-p', port], {
+    // Build if not already built
+    const buildDir = path.join(PKG_ROOT, '.next');
+    if (!fs.existsSync(buildDir)) {
+      console.log('\n  IM - First run: building... (this may take a minute)\n');
+      const buildResult = spawn(process.execPath, [nextCli, 'build'], {
+        cwd: PKG_ROOT,
+        stdio: 'inherit',
+        env: { ...process.env, NODE_ENV: 'production' },
+      });
+      await new Promise<void>((resolve, reject) => {
+        buildResult.on('exit', (code) => {
+          if (code !== 0) reject(new Error(`Build failed with code ${code}`));
+          else resolve();
+        });
+        buildResult.on('error', reject);
+      });
+    }
+
+    console.log(`\n  IM - Idea Manager`);
+    console.log(`  Starting on http://localhost:${port}\n`);
+
+    // Run production server (next start)
+    const child = spawn(process.execPath, [nextCli, 'start', '-p', port], {
       cwd: PKG_ROOT,
       stdio: 'inherit',
-      env: { ...process.env, NODE_ENV: 'development' },
+      env: { ...process.env, NODE_ENV: 'production' },
     });
 
     child.on('error', (err) => {

package/src/lib/db/index.ts

@@ -1,16 +1,190 @@
-import Database from 'better-sqlite3';
+import fs from 'fs';
 import { getDbPath } from '../utils/paths';
 import { initSchema } from './schema';
 
-let db: Database.Database | null = null;
+// Compatibility wrapper: mimics better-sqlite3 API on top of sql.js
+class DatabaseWrapper {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private db: any;
+  private dbPath: string;
+  private dirty = false;
+  private saveTimer: ReturnType<typeof setTimeout> | null = null;
 
-export function getDb(): Database.Database {
-  if (!db) {
-    const dbPath = getDbPath();
-    db = new Database(dbPath);
-    db.pragma('journal_mode = WAL');
-    db.pragma('foreign_keys = ON');
-    initSchema(db);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor(db: any, dbPath: string) {
+    this.db = db;
+    this.dbPath = dbPath;
   }
-  return db;
+
+  private save() {
+    if (!this.dirty) return;
+    const data = this.db.export();
+    fs.writeFileSync(this.dbPath, Buffer.from(data));
+    this.dirty = false;
+  }
+
+  private scheduleSave() {
+    this.dirty = true;
+    if (this.saveTimer) return;
+    this.saveTimer = setTimeout(() => {
+      this.save();
+      this.saveTimer = null;
+    }, 100);
+  }
+
+  private immediatelySave() {
+    this.dirty = true;
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer);
+      this.saveTimer = null;
+    }
+    this.save();
+  }
+
+  private rowsToObjects(columns: string[], values: unknown[][]): Record<string, unknown>[] {
+    return values.map(row => {
+      const obj: Record<string, unknown> = {};
+      columns.forEach((col: string, i: number) => { obj[col] = row[i]; });
+      return obj;
+    });
+  }
+
+  prepare(sql: string) {
+    const self = this;
+    const isWrite = /^\s*(INSERT|UPDATE|DELETE|CREATE|ALTER|DROP)/i.test(sql);
+
+    return {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      all(...params: unknown[]): any[] {
+        const stmt = self.db.prepare(sql);
+        if (params.length > 0) stmt.bind(params);
+        const columns: string[] = stmt.getColumnNames();
+        const rows: unknown[][] = [];
+        while (stmt.step()) {
+          rows.push(stmt.get());
+        }
+        stmt.free();
+        return self.rowsToObjects(columns, rows);
+      },
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      get(...params: unknown[]): any {
+        const stmt = self.db.prepare(sql);
+        if (params.length > 0) stmt.bind(params);
+        let result: Record<string, unknown> | undefined;
+        if (stmt.step()) {
+          const columns = stmt.getColumnNames();
+          const row = stmt.get();
+          const obj: Record<string, unknown> = {};
+          columns.forEach((col: string, i: number) => { obj[col] = row[i]; });
+          result = obj;
+        }
+        stmt.free();
+        return result;
+      },
+
+      run(...params: unknown[]) {
+        self.db.run(sql, params);
+        if (isWrite) self.scheduleSave();
+        const changes = self.db.getRowsModified();
+        return { changes };
+      },
+    };
+  }
+
+  exec(sql: string) {
+    this.db.exec(sql);
+    if (/^\s*(INSERT|UPDATE|DELETE|CREATE|ALTER|DROP)/im.test(sql)) {
+      this.scheduleSave();
+    }
+  }
+
+  pragma(str: string) {
+    if (str.startsWith('table_info(')) {
+      const table = str.match(/table_info\((\w+)\)/)?.[1];
+      if (!table) return [];
+      const result = this.db.exec(`PRAGMA table_info(${table})`);
+      if (!result.length) return [];
+      return this.rowsToObjects(result[0].columns, result[0].values);
+    }
+    if (str.includes('journal_mode') || str.includes('wal_checkpoint')) {
+      this.immediatelySave();
+      return 'memory';
+    }
+    if (str.includes('foreign_keys')) {
+      try { this.db.run(`PRAGMA ${str}`); } catch { /* ignore */ }
+      return;
+    }
+    try {
+      const result = this.db.exec(`PRAGMA ${str}`);
+      if (result.length > 0 && result[0].values.length > 0) {
+        return result[0].values[0][0];
+      }
+    } catch { /* ignore */ }
+  }
+
+  transaction<T>(fn: () => T): () => T {
+    const self = this;
+    return () => {
+      self.db.run('BEGIN');
+      try {
+        const result = fn();
+        self.db.run('COMMIT');
+        self.immediatelySave();
+        return result;
+      } catch (err) {
+        self.db.run('ROLLBACK');
+        throw err;
+      }
+    };
+  }
+
+  close() {
+    this.immediatelySave();
+    this.db.close();
+  }
+}
+
+let wrapper: DatabaseWrapper | null = null;
+let initPromise: Promise<DatabaseWrapper> | null = null;
+
+async function initAsync(): Promise<DatabaseWrapper> {
+  if (wrapper) return wrapper;
+
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const initSqlJs = require('sql.js/dist/sql-asm.js');
+  const SQL = await initSqlJs();
+
+  const dbPath = getDbPath();
+  let db;
+  if (fs.existsSync(dbPath)) {
+    const fileBuffer = fs.readFileSync(dbPath);
+    db = new SQL.Database(fileBuffer);
+  } else {
+    db = new SQL.Database();
+  }
+
+  wrapper = new DatabaseWrapper(db, dbPath);
+  initSchema(wrapper as unknown as Parameters<typeof initSchema>[0]);
+
+  process.on('exit', () => wrapper?.close());
+
+  return wrapper;
+}
+
+/** Call once before using getDb(). Safe to call multiple times. */
+export async function ensureDb(): Promise<DatabaseWrapper> {
+  if (wrapper) return wrapper;
+  if (!initPromise) {
+    initPromise = initAsync();
+  }
+  return initPromise;
+}
+
+/** Sync getter — only works after ensureDb() has resolved. */
+export function getDb(): DatabaseWrapper {
+  if (!wrapper) {
+    throw new Error('Database not initialized. Call await ensureDb() first.');
+  }
+  return wrapper;
 }

package/src/lib/db/schema.ts

@@ -1,6 +1,5 @@
-import type Database from 'better-sqlite3';
-
-export function initSchema(db: Database.Database): void {
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function initSchema(db: any): void {
   db.exec(`
     CREATE TABLE IF NOT EXISTS projects (
       id TEXT PRIMARY KEY,

package/src/lib/sync/exporter.ts

@@ -1,5 +1,5 @@
 import fs from 'fs';
-import { getDb } from '../db';
+import { ensureDb, getDb } from '../db';
 
 // v2 active tables
 const V2_TABLES = ['projects', 'brainstorms', 'sub_projects', 'tasks', 'task_prompts', 'task_conversations'];
@@ -9,7 +9,8 @@ function getExistingTables(db: ReturnType<typeof getDb>): string[] {
   return rows.map(r => r.name);
 }
 
-export function exportToFile(filePath: string): { tables: Record<string, number> } {
+export async function exportToFile(filePath: string): Promise<{ tables: Record<string, number> }> {
+  await ensureDb();
   const db = getDb();
   const existingTables = getExistingTables(db);
 

package/src/lib/sync/importer.ts

@@ -1,5 +1,5 @@
 import fs from 'fs';
-import { getDb } from '../db';
+import { ensureDb, getDb } from '../db';
 import { getDbPath } from '../utils/paths';
 
 // Import order: parents first, then children
@@ -7,7 +7,8 @@ const IMPORT_ORDER = ['projects', 'brainstorms', 'sub_projects', 'tasks', 'task_
 // Delete order: children first, then parents
 const DELETE_ORDER = [...IMPORT_ORDER].reverse();
 
-export function backupDb(): string {
+export async function backupDb(): Promise<string> {
+  await ensureDb();
   const dbPath = getDbPath();
   const db = getDb();
   // Flush WAL before backup
@@ -18,7 +19,8 @@ export function backupDb(): string {
   return backupPath;
 }
 
-export function importFromFile(filePath: string): { tables: Record<string, number> } {
+export async function importFromFile(filePath: string): Promise<{ tables: Record<string, number> }> {
+  await ensureDb();
   const raw = fs.readFileSync(filePath, 'utf-8');
   const data = JSON.parse(raw);
 

package/src/lib/sync/index.ts

@@ -115,7 +115,7 @@ export async function syncInit() {
   // Initial export + push if repo is empty
   if (!fs.existsSync(path.join(syncDir, SYNC_FILE))) {
     console.log('  Performing initial export...');
-    const { tables } = exportToFile(path.join(syncDir, SYNC_FILE));
+    const { tables } = await exportToFile(path.join(syncDir, SYNC_FILE));
     printCounts('Exported', tables);
 
     try {
@@ -142,7 +142,7 @@ export async function syncPush(message?: string) {
 
   // Export
   const filePath = path.join(syncDir, SYNC_FILE);
-  const { tables } = exportToFile(filePath);
+  const { tables } = await exportToFile(filePath);
   printCounts('Exported', tables);
 
   // Commit + push
@@ -194,12 +194,12 @@ export async function syncPull(opts: { backup?: boolean } = {}) {
 
   // Backup
   if (opts.backup !== false) {
-    const backupPath = backupDb();
+    const backupPath = await backupDb();
     console.log(`  Backup: ${backupPath}`);
   }
 
   // Import
-  const { tables } = importFromFile(filePath);
+  const { tables } = await importFromFile(filePath);
   printCounts('Imported', tables);
   console.log('  Done. Refresh the browser to see updated data.\n');
 }

package/src/lib/watcher.ts

@@ -1,4 +1,5 @@
 import fs from 'fs';
+import { ensureDb } from './db';
 import { runAgent } from './ai/client';
 import { listProjects, getProject } from './db/queries/projects';
 import { getSubProject } from './db/queries/sub-projects';
@@ -163,6 +164,7 @@ async function executeTask(task: ITask, project: IProject, options: WatcherOptio
 }
 
 export async function startWatcher(options: WatcherOptions): Promise<void> {
+  await ensureDb();
   if (options.projectId) {
     const project = getProject(options.projectId);
     if (!project) {