@compilr-dev/sdk 0.2.2 → 0.2.4

package/dist/platform/sqlite/plan-repository.d.ts

@@ -0,0 +1,24 @@
+/**
+ * SQLite Plan Repository — Concrete implementation of IPlanRepository.
+ *
+ * Plans are stored in project_documents with doc_type='plan'.
+ */
+import type Database from 'better-sqlite3';
+import type { IPlanRepository } from '../repositories.js';
+import type { Plan, PlanSummary, PlanWithWorkItem, PlanStatus, CreatePlanInput, UpdatePlanInput, ListPlansOptions } from '../types.js';
+export declare class SQLitePlanRepository implements IPlanRepository {
+    private readonly db;
+    constructor(db: Database.Database);
+    create(input: CreatePlanInput): Promise<Plan>;
+    getById(id: number): Promise<Plan | null>;
+    getByName(projectId: number, name: string): Promise<Plan | null>;
+    getWithWorkItem(id: number): Promise<PlanWithWorkItem | null>;
+    update(id: number, input: UpdatePlanInput): Promise<Plan | null>;
+    delete(id: number): Promise<boolean>;
+    list(projectId: number, options?: ListPlansOptions): Promise<PlanSummary[]>;
+    countByStatus(projectId: number): Promise<Record<PlanStatus, number>>;
+    getInProgress(projectId: number): Promise<PlanSummary[]>;
+    hasInProgress(projectId: number): Promise<boolean>;
+    linkWorkItem(planId: number, workItemId: number): Promise<Plan | null>;
+    unlinkWorkItem(planId: number): Promise<Plan | null>;
+}

package/dist/platform/sqlite/plan-repository.js

@@ -0,0 +1,205 @@
+/**
+ * SQLite Plan Repository — Concrete implementation of IPlanRepository.
+ *
+ * Plans are stored in project_documents with doc_type='plan'.
+ */
+const VALID_TRANSITIONS = {
+    draft: ['approved', 'abandoned'],
+    approved: ['in_progress', 'abandoned'],
+    in_progress: ['completed', 'abandoned'],
+    completed: [],
+    abandoned: ['draft'],
+};
+function recordToPlan(record) {
+    return {
+        id: record.id,
+        projectId: record.project_id,
+        name: record.title,
+        content: record.content,
+        status: record.status ?? 'draft',
+        workItemId: record.work_item_id,
+        createdAt: new Date(record.created_at),
+        updatedAt: new Date(record.updated_at),
+    };
+}
+function recordToPlanSummary(record) {
+    return {
+        id: record.id,
+        name: record.title,
+        status: record.status ?? 'draft',
+        workItemId: record.work_item_id,
+        workItemTitle: record.work_item_title,
+        workItemItemId: record.work_item_item_id,
+        updatedAt: new Date(record.updated_at),
+    };
+}
+export class SQLitePlanRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    create(input) {
+        const now = new Date().toISOString();
+        const result = this.db
+            .prepare(`INSERT INTO project_documents (
+          project_id, doc_type, title, content, status, work_item_id, created_at, updated_at
+        ) VALUES (?, 'plan', ?, ?, 'draft', ?, ?, ?)`)
+            .run(input.project_id, input.name, input.content, input.work_item_id ?? null, now, now);
+        const record = this.db
+            .prepare(`SELECT * FROM project_documents WHERE id = ? AND doc_type = 'plan'`)
+            .get(Number(result.lastInsertRowid));
+        return Promise.resolve(recordToPlan(record));
+    }
+    getById(id) {
+        const record = this.db
+            .prepare(`SELECT * FROM project_documents WHERE id = ? AND doc_type = 'plan'`)
+            .get(id);
+        return Promise.resolve(record ? recordToPlan(record) : null);
+    }
+    getByName(projectId, name) {
+        const record = this.db
+            .prepare(`SELECT * FROM project_documents WHERE project_id = ? AND doc_type = 'plan' AND title = ?`)
+            .get(projectId, name);
+        return Promise.resolve(record ? recordToPlan(record) : null);
+    }
+    getWithWorkItem(id) {
+        const record = this.db
+            .prepare(`SELECT pd.*, wi.item_id as wi_item_id, wi.title as wi_title, wi.status as wi_status
+         FROM project_documents pd
+         LEFT JOIN work_items wi ON pd.work_item_id = wi.id
+         WHERE pd.id = ? AND pd.doc_type = 'plan'`)
+            .get(id);
+        if (!record)
+            return Promise.resolve(null);
+        const plan = recordToPlan(record);
+        if (record.wi_item_id && record.work_item_id !== null) {
+            plan.workItem = {
+                id: record.work_item_id,
+                itemId: record.wi_item_id,
+                title: record.wi_title ?? '',
+                status: record.wi_status ?? '',
+            };
+        }
+        return Promise.resolve(plan);
+    }
+    update(id, input) {
+        const currentRecord = this.db
+            .prepare(`SELECT * FROM project_documents WHERE id = ? AND doc_type = 'plan'`)
+            .get(id);
+        if (!currentRecord)
+            return Promise.resolve(null);
+        const currentStatus = currentRecord.status ?? 'draft';
+        if (input.status && input.status !== currentStatus) {
+            if (!VALID_TRANSITIONS[currentStatus].includes(input.status)) {
+                throw new Error(`Invalid status transition: ${currentStatus} → ${input.status}`);
+            }
+        }
+        const updates = [];
+        const params = [];
+        if (input.content !== undefined) {
+            updates.push('content = ?');
+            params.push(input.content);
+        }
+        if (input.status !== undefined) {
+            updates.push('status = ?');
+            params.push(input.status);
+        }
+        if (input.work_item_id !== undefined) {
+            updates.push('work_item_id = ?');
+            params.push(input.work_item_id);
+        }
+        if (updates.length === 0)
+            return Promise.resolve(recordToPlan(currentRecord));
+        updates.push('updated_at = ?');
+        params.push(new Date().toISOString());
+        params.push(id);
+        this.db
+            .prepare(`UPDATE project_documents SET ${updates.join(', ')} WHERE id = ? AND doc_type = 'plan'`)
+            .run(...params);
+        return this.getById(id);
+    }
+    delete(id) {
+        const result = this.db
+            .prepare(`DELETE FROM project_documents WHERE id = ? AND doc_type = 'plan'`)
+            .run(id);
+        return Promise.resolve(result.changes > 0);
+    }
+    list(projectId, options = {}) {
+        const conditions = ['pd.project_id = ?', "pd.doc_type = 'plan'"];
+        const params = [projectId];
+        if (options.status) {
+            if (Array.isArray(options.status)) {
+                const placeholders = options.status.map(() => '?').join(', ');
+                conditions.push(`pd.status IN (${placeholders})`);
+                params.push(...options.status);
+            }
+            else {
+                conditions.push('pd.status = ?');
+                params.push(options.status);
+            }
+        }
+        if (options.work_item_id !== undefined) {
+            conditions.push('pd.work_item_id = ?');
+            params.push(options.work_item_id);
+        }
+        let orderBy = 'pd.updated_at DESC';
+        switch (options.order_by) {
+            case 'updated_asc':
+                orderBy = 'pd.updated_at ASC';
+                break;
+            case 'created_desc':
+                orderBy = 'pd.created_at DESC';
+                break;
+            case 'name_asc':
+                orderBy = 'pd.title ASC';
+                break;
+        }
+        const limit = options.limit ?? 20;
+        const query = `
+      SELECT pd.*, wi.title as work_item_title, wi.item_id as work_item_item_id
+      FROM project_documents pd
+      LEFT JOIN work_items wi ON pd.work_item_id = wi.id
+      WHERE ${conditions.join(' AND ')}
+      ORDER BY ${orderBy}
+      LIMIT ?
+    `;
+        params.push(limit);
+        const records = this.db.prepare(query).all(...params);
+        return Promise.resolve(records.map(recordToPlanSummary));
+    }
+    countByStatus(projectId) {
+        const results = this.db
+            .prepare(`SELECT status, COUNT(*) as count FROM project_documents
+         WHERE project_id = ? AND doc_type = 'plan' GROUP BY status`)
+            .all(projectId);
+        const counts = {
+            draft: 0,
+            approved: 0,
+            in_progress: 0,
+            completed: 0,
+            abandoned: 0,
+        };
+        for (const row of results) {
+            if (row.status && row.status in counts) {
+                counts[row.status] = row.count;
+            }
+        }
+        return Promise.resolve(counts);
+    }
+    getInProgress(projectId) {
+        return this.list(projectId, { status: 'in_progress' });
+    }
+    hasInProgress(projectId) {
+        const result = this.db
+            .prepare(`SELECT COUNT(*) as count FROM project_documents
+         WHERE project_id = ? AND doc_type = 'plan' AND status = 'in_progress'`)
+            .get(projectId);
+        return Promise.resolve(result.count > 0);
+    }
+    linkWorkItem(planId, workItemId) {
+        return this.update(planId, { work_item_id: workItemId });
+    }
+    unlinkWorkItem(planId) {
+        return this.update(planId, { work_item_id: null });
+    }
+}

package/dist/platform/sqlite/project-repository.d.ts

@@ -0,0 +1,34 @@
+/**
+ * SQLite Project Repository — Concrete implementation of IProjectRepository.
+ *
+ * All methods return Promises (wrapping synchronous better-sqlite3 calls)
+ * to satisfy the async IProjectRepository interface.
+ */
+import type Database from 'better-sqlite3';
+import type { IProjectRepository } from '../repositories.js';
+import type { Project, ProjectStatus, CreateProjectInput, UpdateProjectInput, ProjectListOptions, ProjectListResult } from '../types.js';
+/**
+ * Options for customizing project deletion behavior.
+ * Consumers can provide a callback to clean up platform-specific files.
+ */
+export interface ProjectDeleteHooks {
+    onDelete?: (projectId: number) => void;
+}
+export declare class SQLiteProjectRepository implements IProjectRepository {
+    private readonly db;
+    private readonly deleteHooks?;
+    constructor(db: Database.Database, hooks?: ProjectDeleteHooks);
+    create(input: CreateProjectInput): Promise<Project>;
+    getById(id: number): Promise<Project | null>;
+    getByName(name: string): Promise<Project | null>;
+    getByPath(path: string): Promise<Project | null>;
+    getByDocsPath(docsPath: string): Promise<Project | null>;
+    findByPath(searchPath: string): Promise<Project | null>;
+    list(options?: ProjectListOptions): Promise<ProjectListResult>;
+    update(id: number, input: UpdateProjectInput): Promise<Project | null>;
+    touch(id: number): Promise<void>;
+    delete(id: number): Promise<boolean>;
+    archive(id: number): Promise<Project | null>;
+    isNameAvailable(name: string, excludeId?: number): Promise<boolean>;
+    getStatusCounts(): Promise<Record<ProjectStatus, number>>;
+}

package/dist/platform/sqlite/project-repository.js

@@ -0,0 +1,282 @@
+/**
+ * SQLite Project Repository — Concrete implementation of IProjectRepository.
+ *
+ * All methods return Promises (wrapping synchronous better-sqlite3 calls)
+ * to satisfy the async IProjectRepository interface.
+ */
+function recordToProject(record) {
+    return {
+        id: record.id,
+        name: record.name,
+        displayName: record.display_name,
+        description: record.description,
+        type: record.type,
+        status: record.status,
+        path: record.path,
+        docsPath: record.docs_path,
+        repoPattern: record.repo_pattern,
+        language: record.language,
+        framework: record.framework,
+        packageManager: record.package_manager,
+        runtimeVersion: record.runtime_version,
+        commands: record.commands ? JSON.parse(record.commands) : null,
+        gitRemote: record.git_remote,
+        gitBranch: record.git_branch,
+        workflowMode: record.workflow_mode,
+        lifecycleState: record.lifecycle_state,
+        currentItemId: record.current_item_id,
+        lastContext: record.last_context
+            ? JSON.parse(record.last_context)
+            : null,
+        metadata: record.metadata ? JSON.parse(record.metadata) : null,
+        createdAt: new Date(record.created_at),
+        updatedAt: new Date(record.updated_at),
+        lastActivityAt: record.last_activity_at ? new Date(record.last_activity_at) : null,
+    };
+}
+export class SQLiteProjectRepository {
+    db;
+    deleteHooks;
+    constructor(db, hooks) {
+        this.db = db;
+        this.deleteHooks = hooks;
+    }
+    create(input) {
+        const now = new Date().toISOString();
+        const result = this.db
+            .prepare(`INSERT INTO projects (
+        name, display_name, description, type, path, docs_path, repo_pattern,
+        language, framework, package_manager, runtime_version, commands,
+        git_remote, git_branch, workflow_mode, metadata,
+        created_at, updated_at, last_activity_at
+      ) VALUES (
+        @name, @display_name, @description, @type, @path, @docs_path, @repo_pattern,
+        @language, @framework, @package_manager, @runtime_version, @commands,
+        @git_remote, @git_branch, @workflow_mode, @metadata,
+        @created_at, @updated_at, @last_activity_at
+      )`)
+            .run({
+            name: input.name,
+            display_name: input.display_name,
+            description: input.description ?? null,
+            type: input.type ?? 'general',
+            path: input.path,
+            docs_path: input.docs_path ?? null,
+            repo_pattern: input.repo_pattern ?? 'single',
+            language: input.language ?? null,
+            framework: input.framework ?? null,
+            package_manager: input.package_manager ?? null,
+            runtime_version: input.runtime_version ?? null,
+            commands: input.commands ? JSON.stringify(input.commands) : null,
+            git_remote: input.git_remote ?? null,
+            git_branch: input.git_branch ?? 'main',
+            workflow_mode: input.workflow_mode ?? 'flexible',
+            metadata: input.metadata ? JSON.stringify(input.metadata) : null,
+            created_at: now,
+            updated_at: now,
+            last_activity_at: now,
+        });
+        const record = this.db
+            .prepare('SELECT * FROM projects WHERE id = ?')
+            .get(Number(result.lastInsertRowid));
+        if (!record)
+            throw new Error('Failed to create project');
+        return Promise.resolve(recordToProject(record));
+    }
+    getById(id) {
+        const record = this.db.prepare('SELECT * FROM projects WHERE id = ?').get(id);
+        return Promise.resolve(record ? recordToProject(record) : null);
+    }
+    getByName(name) {
+        const record = this.db.prepare('SELECT * FROM projects WHERE name = ?').get(name);
+        return Promise.resolve(record ? recordToProject(record) : null);
+    }
+    getByPath(path) {
+        const record = this.db.prepare('SELECT * FROM projects WHERE path = ?').get(path);
+        return Promise.resolve(record ? recordToProject(record) : null);
+    }
+    getByDocsPath(docsPath) {
+        const record = this.db.prepare('SELECT * FROM projects WHERE docs_path = ?').get(docsPath);
+        return Promise.resolve(record ? recordToProject(record) : null);
+    }
+    async findByPath(searchPath) {
+        let project = await this.getByPath(searchPath);
+        if (project)
+            return project;
+        project = await this.getByDocsPath(searchPath);
+        if (project)
+            return project;
+        const parts = searchPath.split('/').filter(Boolean);
+        for (let i = parts.length - 1; i >= 0; i--) {
+            const parentPath = '/' + parts.slice(0, i).join('/');
+            if (!parentPath || parentPath === '/')
+                break;
+            project = await this.getByPath(parentPath);
+            if (project)
+                return project;
+            project = await this.getByDocsPath(parentPath);
+            if (project)
+                return project;
+        }
+        return null;
+    }
+    list(options) {
+        const conditions = [];
+        const params = {};
+        if (options?.status && options.status !== 'all') {
+            conditions.push('status = @status');
+            params.status = options.status;
+        }
+        if (options?.type && options.type !== 'all') {
+            conditions.push('type = @type');
+            params.type = options.type;
+        }
+        const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+        const countResult = this.db
+            .prepare(`SELECT COUNT(*) as count FROM projects ${whereClause}`)
+            .get(params);
+        let query = `SELECT * FROM projects ${whereClause} ORDER BY last_activity_at DESC NULLS LAST, updated_at DESC`;
+        if (options?.limit) {
+            query += ` LIMIT @limit`;
+            params.limit = options.limit;
+        }
+        if (options?.offset) {
+            query += ` OFFSET @offset`;
+            params.offset = options.offset;
+        }
+        const records = this.db.prepare(query).all(params);
+        return Promise.resolve({
+            projects: records.map(recordToProject),
+            total: countResult.count,
+        });
+    }
+    update(id, input) {
+        const updates = [];
+        const params = { id };
+        if (input.display_name !== undefined) {
+            updates.push('display_name = @display_name');
+            params.display_name = input.display_name;
+        }
+        if (input.description !== undefined) {
+            updates.push('description = @description');
+            params.description = input.description;
+        }
+        if (input.type !== undefined) {
+            updates.push('type = @type');
+            params.type = input.type;
+        }
+        if (input.status !== undefined) {
+            updates.push('status = @status');
+            params.status = input.status;
+        }
+        if (input.docs_path !== undefined) {
+            updates.push('docs_path = @docs_path');
+            params.docs_path = input.docs_path;
+        }
+        if (input.repo_pattern !== undefined) {
+            updates.push('repo_pattern = @repo_pattern');
+            params.repo_pattern = input.repo_pattern;
+        }
+        if (input.language !== undefined) {
+            updates.push('language = @language');
+            params.language = input.language;
+        }
+        if (input.framework !== undefined) {
+            updates.push('framework = @framework');
+            params.framework = input.framework;
+        }
+        if (input.package_manager !== undefined) {
+            updates.push('package_manager = @package_manager');
+            params.package_manager = input.package_manager;
+        }
+        if (input.runtime_version !== undefined) {
+            updates.push('runtime_version = @runtime_version');
+            params.runtime_version = input.runtime_version;
+        }
+        if (input.commands !== undefined) {
+            updates.push('commands = @commands');
+            params.commands = JSON.stringify(input.commands);
+        }
+        if (input.git_remote !== undefined) {
+            updates.push('git_remote = @git_remote');
+            params.git_remote = input.git_remote;
+        }
+        if (input.git_branch !== undefined) {
+            updates.push('git_branch = @git_branch');
+            params.git_branch = input.git_branch;
+        }
+        if (input.workflow_mode !== undefined) {
+            updates.push('workflow_mode = @workflow_mode');
+            params.workflow_mode = input.workflow_mode;
+        }
+        if (input.lifecycle_state !== undefined) {
+            updates.push('lifecycle_state = @lifecycle_state');
+            params.lifecycle_state = input.lifecycle_state;
+        }
+        if (input.current_item_id !== undefined) {
+            updates.push('current_item_id = @current_item_id');
+            params.current_item_id = input.current_item_id;
+        }
+        if (input.last_context !== undefined) {
+            updates.push('last_context = @last_context');
+            params.last_context = JSON.stringify(input.last_context);
+        }
+        if (input.metadata !== undefined) {
+            updates.push('metadata = @metadata');
+            params.metadata = JSON.stringify(input.metadata);
+        }
+        if (updates.length === 0) {
+            return this.getById(id);
+        }
+        updates.push('updated_at = @updated_at');
+        params.updated_at = new Date().toISOString();
+        this.db.prepare(`UPDATE projects SET ${updates.join(', ')} WHERE id = @id`).run(params);
+        return this.getById(id);
+    }
+    touch(id) {
+        const now = new Date().toISOString();
+        this.db
+            .prepare('UPDATE projects SET last_activity_at = ?, updated_at = ? WHERE id = ?')
+            .run(now, now, id);
+        return Promise.resolve();
+    }
+    delete(id) {
+        const project = this.db.prepare('SELECT status FROM projects WHERE id = ?').get(id);
+        if (!project)
+            return Promise.resolve(false);
+        if (project.status !== 'archived') {
+            throw new Error('Project must be archived before deletion. Use archive() first.');
+        }
+        const result = this.db.prepare('DELETE FROM projects WHERE id = ?').run(id);
+        if (result.changes > 0) {
+            this.deleteHooks?.onDelete?.(id);
+        }
+        return Promise.resolve(result.changes > 0);
+    }
+    archive(id) {
+        return this.update(id, { status: 'archived' });
+    }
+    isNameAvailable(name, excludeId) {
+        const query = excludeId
+            ? 'SELECT id FROM projects WHERE name = ? AND id != ?'
+            : 'SELECT id FROM projects WHERE name = ?';
+        const params = excludeId ? [name, excludeId] : [name];
+        const result = this.db.prepare(query).get(...params);
+        return Promise.resolve(!result);
+    }
+    getStatusCounts() {
+        const results = this.db
+            .prepare('SELECT status, COUNT(*) as count FROM projects GROUP BY status')
+            .all();
+        const counts = {
+            active: 0,
+            paused: 0,
+            completed: 0,
+            archived: 0,
+        };
+        for (const row of results) {
+            counts[row.status] = row.count;
+        }
+        return Promise.resolve(counts);
+    }
+}

package/dist/platform/sqlite/schema.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Database Schema for compilr-dev workflow system
+ *
+ * Shared between CLI and Desktop — both access ~/.compilr-dev/projects.db
+ * Schema version must be kept in sync across all consumers.
+ */
+export declare const SCHEMA_VERSION = 6;
+export declare const SCHEMA_SQL = "\n-- Schema version tracking\nCREATE TABLE IF NOT EXISTS schema_version (\n  version INTEGER PRIMARY KEY,\n  applied_at DATETIME DEFAULT CURRENT_TIMESTAMP\n);\n\n-- Projects table\nCREATE TABLE IF NOT EXISTS projects (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  name TEXT UNIQUE NOT NULL,\n  display_name TEXT NOT NULL,\n  description TEXT,\n  type TEXT DEFAULT 'general',\n  status TEXT DEFAULT 'active',\n  path TEXT NOT NULL,\n  docs_path TEXT,\n  repo_pattern TEXT DEFAULT 'single',\n  language TEXT,\n  framework TEXT,\n  package_manager TEXT,\n  runtime_version TEXT,\n  commands TEXT,\n  git_remote TEXT,\n  git_branch TEXT DEFAULT 'main',\n  workflow_mode TEXT DEFAULT 'flexible',\n  lifecycle_state TEXT DEFAULT 'setup',\n  current_item_id TEXT,\n  last_context TEXT,\n  metadata TEXT,\n  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,\n  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,\n  last_activity_at DATETIME\n);\n\n-- Work items (backlog items, tasks, bugs)\nCREATE TABLE IF NOT EXISTS work_items (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  project_id INTEGER NOT NULL,\n  item_number INTEGER NOT NULL,\n  item_id TEXT NOT NULL,\n  type TEXT NOT NULL,\n  status TEXT DEFAULT 'backlog',\n  priority TEXT DEFAULT 'medium',\n  guided_step TEXT,\n  owner TEXT,\n  title TEXT NOT NULL,\n  description TEXT,\n  estimated_effort TEXT,\n  actual_minutes INTEGER,\n  completed_at DATETIME,\n  completed_by TEXT,\n  commit_hash TEXT,\n  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,\n  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,\n  FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,\n  UNIQUE (project_id, item_id)\n);\n\n-- Project documents (PRD, architecture, plans, etc.)\nCREATE TABLE IF NOT EXISTS project_documents (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  project_id INTEGER NOT NULL,\n  doc_type TEXT NOT NULL,\n  title TEXT NOT NULL,\n  content TEXT NOT NULL,\n  status TEXT,\n  work_item_id INTEGER,\n  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,\n  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,\n  FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,\n  FOREIGN KEY (work_item_id) REFERENCES work_items(id) ON DELETE SET NULL\n);\n\n-- Work item history (audit trail)\nCREATE TABLE IF NOT EXISTS work_item_history (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  work_item_id INTEGER NOT NULL,\n  project_id INTEGER NOT NULL,\n  action TEXT NOT NULL,\n  old_value TEXT,\n  new_value TEXT,\n  notes TEXT,\n  changed_by TEXT,\n  changed_at DATETIME DEFAULT CURRENT_TIMESTAMP,\n  FOREIGN KEY (work_item_id) REFERENCES work_items(id) ON DELETE CASCADE,\n  FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE\n);\n\n-- Indexes\nCREATE INDEX IF NOT EXISTS idx_projects_path ON projects(path);\nCREATE INDEX IF NOT EXISTS idx_projects_docs_path ON projects(docs_path);\nCREATE INDEX IF NOT EXISTS idx_projects_status ON projects(status);\nCREATE INDEX IF NOT EXISTS idx_work_items_project ON work_items(project_id);\nCREATE INDEX IF NOT EXISTS idx_work_items_status ON work_items(status);\nCREATE INDEX IF NOT EXISTS idx_work_items_priority ON work_items(priority);\nCREATE INDEX IF NOT EXISTS idx_work_items_owner ON work_items(owner);\nCREATE INDEX IF NOT EXISTS idx_project_documents_project ON project_documents(project_id);\nCREATE INDEX IF NOT EXISTS idx_project_documents_type ON project_documents(doc_type);\nCREATE INDEX IF NOT EXISTS idx_project_documents_status ON project_documents(status);\nCREATE INDEX IF NOT EXISTS idx_project_documents_work_item ON project_documents(work_item_id);\nCREATE INDEX IF NOT EXISTS idx_work_item_history_item ON work_item_history(work_item_id);\n\n-- Terminal sessions (multi-terminal awareness)\nCREATE TABLE IF NOT EXISTS terminal_sessions (\n  id TEXT PRIMARY KEY,\n  project_id INTEGER,\n  pid INTEGER NOT NULL,\n  tty_path TEXT,\n  label TEXT,\n  started_at DATETIME DEFAULT CURRENT_TIMESTAMP,\n  last_heartbeat DATETIME DEFAULT CURRENT_TIMESTAMP,\n  active_agent TEXT DEFAULT 'default',\n  agents_json TEXT DEFAULT '[]',\n  status TEXT DEFAULT 'active',\n  FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE SET NULL\n);\nCREATE INDEX IF NOT EXISTS idx_terminal_sessions_project ON terminal_sessions(project_id);\nCREATE INDEX IF NOT EXISTS idx_terminal_sessions_status ON terminal_sessions(status);\n\n-- File locks (multi-terminal file lock awareness)\nCREATE TABLE IF NOT EXISTS file_locks (\n  path TEXT NOT NULL,\n  project_id INTEGER NOT NULL,\n  session_id TEXT NOT NULL,\n  agent_id TEXT NOT NULL,\n  locked_at DATETIME DEFAULT CURRENT_TIMESTAMP,\n  PRIMARY KEY (path, project_id),\n  FOREIGN KEY (session_id) REFERENCES terminal_sessions(id) ON DELETE CASCADE,\n  FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE\n);\nCREATE INDEX IF NOT EXISTS idx_file_locks_session ON file_locks(session_id);\n\n-- Session notifications (cross-session notifications)\nCREATE TABLE IF NOT EXISTS session_notifications (\n  id TEXT PRIMARY KEY,\n  project_id INTEGER NOT NULL,\n  from_session_id TEXT NOT NULL,\n  to_session_id TEXT,\n  type TEXT NOT NULL,\n  title TEXT NOT NULL,\n  message TEXT,\n  payload_json TEXT,\n  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,\n  read_at DATETIME,\n  FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,\n  FOREIGN KEY (from_session_id) REFERENCES terminal_sessions(id) ON DELETE CASCADE\n);\nCREATE INDEX IF NOT EXISTS idx_session_notifications_project ON session_notifications(project_id);\nCREATE INDEX IF NOT EXISTS idx_session_notifications_to_session ON session_notifications(to_session_id);\nCREATE INDEX IF NOT EXISTS idx_session_notifications_unread ON session_notifications(read_at);\n";
+export interface ProjectRecord {
+    id: number;
+    name: string;
+    display_name: string;
+    description: string | null;
+    type: string;
+    status: string;
+    path: string;
+    docs_path: string | null;
+    repo_pattern: string;
+    language: string | null;
+    framework: string | null;
+    package_manager: string | null;
+    runtime_version: string | null;
+    commands: string | null;
+    git_remote: string | null;
+    git_branch: string;
+    workflow_mode: string;
+    lifecycle_state: string;
+    current_item_id: string | null;
+    last_context: string | null;
+    metadata: string | null;
+    created_at: string;
+    updated_at: string;
+    last_activity_at: string | null;
+}
+export interface WorkItemRecord {
+    id: number;
+    project_id: number;
+    item_number: number;
+    item_id: string;
+    type: string;
+    status: string;
+    priority: string;
+    guided_step: string | null;
+    owner: string | null;
+    title: string;
+    description: string | null;
+    estimated_effort: string | null;
+    actual_minutes: number | null;
+    completed_at: string | null;
+    completed_by: string | null;
+    commit_hash: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface ProjectDocumentRecord {
+    id: number;
+    project_id: number;
+    doc_type: string;
+    title: string;
+    content: string;
+    status: string | null;
+    work_item_id: number | null;
+    created_at: string;
+    updated_at: string;
+}