@compilr-dev/sdk 0.2.3 → 0.2.4

package/dist/index.d.ts

@@ -54,6 +54,8 @@ export type { CapabilityPack, CapabilityTier, LoadedCapability, CapabilityCatalo
 export { SystemPromptBuilder, buildSystemPrompt, detectGitRepository, getModuleStats, ALL_MODULES, IDENTITY_MODULE, STYLE_MODULE, TASK_EXECUTION_MODULE, TODO_MANAGEMENT_MODULE, TOOL_USAGE_DIRECT_MODULE, TOOL_USAGE_HINTS_MODULE, PLATFORM_TOOL_HINTS_MODULE, FACTORY_TOOL_HINTS_MODULE, TOOL_USAGE_META_MODULE, DELEGATION_MODULE, GIT_SAFETY_MODULE, SUGGEST_MODULE, IMPORTANT_RULES_MODULE, ENVIRONMENT_MODULE, shouldIncludeModule, getEstimatedTokensForConditions, getTotalEstimatedTokens, } from './system-prompt/index.js';
 export type { SystemPromptContext, BuildResult, SystemPromptModule, ModuleConditions, } from './system-prompt/index.js';
 export type { ProjectType, ProjectStatus, RepoPattern, WorkflowMode, LifecycleState, WorkItemType, WorkItemStatus, WorkItemPriority, GuidedStep, DocumentType, PlanStatus, Project, WorkItem, ProjectDocument, Plan, PlanSummary, PlanWithWorkItem, HistoryEntry, CreateProjectInput, UpdateProjectInput, ProjectListOptions, CreateWorkItemInput, UpdateWorkItemInput, QueryWorkItemsInput, CreateDocumentInput, UpdateDocumentInput, CreatePlanInput, UpdatePlanInput, ListPlansOptions, WorkItemQueryResult, ProjectListResult, BulkCreateItem, IProjectRepository, IWorkItemRepository, IDocumentRepository, IPlanRepository, IAnchorService, IArtifactService, IEpisodeService, AnchorData, ArtifactType, ArtifactData, ArtifactSummaryData, WorkEpisode, ProjectWorkSummary, PlatformContext, PlatformToolsConfig, PlatformHooks, StepCriteria, } from './platform/index.js';
+export { createSQLiteRepositories, SQLiteProjectRepository, SQLiteWorkItemRepository, SQLiteDocumentRepository, SQLitePlanRepository, getDatabase, closeDatabase, closeAllDatabases, databaseExists, SCHEMA_VERSION, SCHEMA_SQL, } from './platform/index.js';
+export type { SQLiteRepositories, CreateSQLiteRepositoriesOptions, ProjectDeleteHooks, ProjectRecord, WorkItemRecord, ProjectDocumentRecord, } from './platform/index.js';
 export { createPlatformTools, createProjectTools, createWorkItemTools, createDocumentTools, createPlanTools, createBacklogTools, createAnchorTools, createArtifactTools, createEpisodeTools, } from './platform/index.js';
 export { STEP_ORDER, GUIDED_STEP_CRITERIA, getNextStep, isValidTransition, getStepCriteria, formatStepDisplay, getStepNumber, } from './platform/index.js';
 export { platformSkills, designSkill, sketchSkill, prdSkill, refineSkill, refineItemSkill, architectureSkill, sessionNotesSkill, buildSkill, scaffoldSkill, } from './skills/index.js';

package/dist/index.js

@@ -113,6 +113,10 @@ ALL_MODULES, IDENTITY_MODULE, STYLE_MODULE, TASK_EXECUTION_MODULE, TODO_MANAGEME
 // Module utilities
 shouldIncludeModule, getEstimatedTokensForConditions, getTotalEstimatedTokens, } from './system-prompt/index.js';
 // =============================================================================
+// Platform SQLite Repositories (concrete implementations)
+// =============================================================================
+export { createSQLiteRepositories, SQLiteProjectRepository, SQLiteWorkItemRepository, SQLiteDocumentRepository, SQLitePlanRepository, getDatabase, closeDatabase, closeAllDatabases, databaseExists, SCHEMA_VERSION, SCHEMA_SQL, } from './platform/index.js';
+// =============================================================================
 // Platform Tools (runtime — createPlatformTools factory + individual factories)
 // =============================================================================
 export { createPlatformTools, createProjectTools, createWorkItemTools, createDocumentTools, createPlanTools, createBacklogTools, createAnchorTools, createArtifactTools, createEpisodeTools, } from './platform/index.js';

package/dist/platform/index.d.ts

@@ -6,5 +6,7 @@ export type { IProjectRepository, IWorkItemRepository, IDocumentRepository, IPla
 export type { IAnchorService, IArtifactService, IEpisodeService, AnchorData, ArtifactType, ArtifactData, ArtifactSummaryData, WorkEpisode, ProjectWorkSummary, } from './services.js';
 export type { PlatformContext, PlatformToolsConfig, PlatformHooks } from './context.js';
 export { createPlatformTools, createProjectTools, createWorkItemTools, createDocumentTools, createPlanTools, createBacklogTools, createAnchorTools, createArtifactTools, createEpisodeTools, } from './tools/index.js';
+export { createSQLiteRepositories, SQLiteProjectRepository, SQLiteWorkItemRepository, SQLiteDocumentRepository, SQLitePlanRepository, getDatabase, closeDatabase, closeAllDatabases, databaseExists, SCHEMA_VERSION, SCHEMA_SQL, } from './sqlite/index.js';
+export type { SQLiteRepositories, CreateSQLiteRepositoriesOptions, ProjectDeleteHooks, ProjectRecord, WorkItemRecord, ProjectDocumentRecord, } from './sqlite/index.js';
 export { STEP_ORDER, GUIDED_STEP_CRITERIA, getNextStep, isValidTransition, getStepCriteria, formatStepDisplay, getStepNumber, } from './workflow.js';
 export type { StepCriteria } from './workflow.js';

package/dist/platform/index.js

@@ -3,5 +3,7 @@
  */
 // Platform tools (runtime)
 export { createPlatformTools, createProjectTools, createWorkItemTools, createDocumentTools, createPlanTools, createBacklogTools, createAnchorTools, createArtifactTools, createEpisodeTools, } from './tools/index.js';
+// SQLite implementations (concrete repositories)
+export { createSQLiteRepositories, SQLiteProjectRepository, SQLiteWorkItemRepository, SQLiteDocumentRepository, SQLitePlanRepository, getDatabase, closeDatabase, closeAllDatabases, databaseExists, SCHEMA_VERSION, SCHEMA_SQL, } from './sqlite/index.js';
 // Workflow (pure step-criteria logic)
 export { STEP_ORDER, GUIDED_STEP_CRITERIA, getNextStep, isValidTransition, getStepCriteria, formatStepDisplay, getStepNumber, } from './workflow.js';

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

@@ -0,0 +1,24 @@
+/**
+ * Database Connection — Shared SQLite singleton for ~/.compilr-dev/projects.db
+ *
+ * Uses better-sqlite3 (optional peer dependency).
+ * Consumers must install better-sqlite3 to use the SQLite repositories.
+ */
+import type Database from 'better-sqlite3';
+/**
+ * Get or create a database connection for the given path.
+ * Uses singleton pattern — same path always returns the same instance.
+ */
+export declare function getDatabase(dbPath: string): Database.Database;
+/**
+ * Close a specific database connection.
+ */
+export declare function closeDatabase(dbPath: string): void;
+/**
+ * Close all database connections.
+ */
+export declare function closeAllDatabases(): void;
+/**
+ * Check if a database file exists at the given path.
+ */
+export declare function databaseExists(dbPath: string): boolean;

package/dist/platform/sqlite/db.js

@@ -0,0 +1,140 @@
+/**
+ * Database Connection — Shared SQLite singleton for ~/.compilr-dev/projects.db
+ *
+ * Uses better-sqlite3 (optional peer dependency).
+ * Consumers must install better-sqlite3 to use the SQLite repositories.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { SCHEMA_SQL, SCHEMA_VERSION } from './schema.js';
+// Database instance (singleton per path)
+const instances = new Map();
+/**
+ * Get or create a database connection for the given path.
+ * Uses singleton pattern — same path always returns the same instance.
+ */
+export function getDatabase(dbPath) {
+    const existing = instances.get(dbPath);
+    if (existing)
+        return existing;
+    // Dynamic require of better-sqlite3 — it's an optional peer dep
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const BetterSqlite3 = require('better-sqlite3');
+    // Ensure directory exists
+    fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+    const db = new BetterSqlite3(dbPath);
+    // Enable foreign keys
+    db.pragma('foreign_keys = ON');
+    // WAL mode for better concurrency
+    db.pragma('journal_mode = WAL');
+    // Prevent SQLITE_BUSY under concurrent access
+    db.pragma('busy_timeout = 5000');
+    // Initialize schema
+    initializeSchema(db);
+    instances.set(dbPath, db);
+    return db;
+}
+/**
+ * Close a specific database connection.
+ */
+export function closeDatabase(dbPath) {
+    const db = instances.get(dbPath);
+    if (db) {
+        db.close();
+        instances.delete(dbPath);
+    }
+}
+/**
+ * Close all database connections.
+ */
+export function closeAllDatabases() {
+    for (const [, db] of instances) {
+        db.close();
+    }
+    instances.clear();
+}
+/**
+ * Check if a database file exists at the given path.
+ */
+export function databaseExists(dbPath) {
+    return fs.existsSync(dbPath);
+}
+// =============================================================================
+// Schema initialization & migrations
+// =============================================================================
+function initializeSchema(db) {
+    const tableExists = db
+        .prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='schema_version'`)
+        .get();
+    if (!tableExists) {
+        db.exec(SCHEMA_SQL);
+        db.prepare('INSERT INTO schema_version (version) VALUES (?)').run(SCHEMA_VERSION);
+        return;
+    }
+    const currentVersion = db.prepare('SELECT MAX(version) as version FROM schema_version').get();
+    if (!currentVersion || currentVersion.version < SCHEMA_VERSION) {
+        runMigrations(db, currentVersion?.version ?? 0, SCHEMA_VERSION);
+    }
+}
+function runMigrations(db, fromVersion, toVersion) {
+    if (fromVersion < 2 && toVersion >= 2) {
+        db.exec(`ALTER TABLE project_documents ADD COLUMN status TEXT;`);
+        db.exec(`ALTER TABLE project_documents ADD COLUMN work_item_id INTEGER REFERENCES work_items(id) ON DELETE SET NULL;`);
+        db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_project_documents_status ON project_documents(status);
+      CREATE INDEX IF NOT EXISTS idx_project_documents_work_item ON project_documents(work_item_id);
+    `);
+        db.prepare('INSERT INTO schema_version (version) VALUES (?)').run(2);
+    }
+    if (fromVersion < 3 && toVersion >= 3) {
+        db.exec(`ALTER TABLE work_items ADD COLUMN owner TEXT;`);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_work_items_owner ON work_items(owner);`);
+        db.prepare('INSERT INTO schema_version (version) VALUES (?)').run(3);
+    }
+    if (fromVersion < 4 && toVersion >= 4) {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS terminal_sessions (
+        id TEXT PRIMARY KEY, project_id INTEGER, pid INTEGER NOT NULL,
+        tty_path TEXT, label TEXT, started_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        last_heartbeat DATETIME DEFAULT CURRENT_TIMESTAMP,
+        active_agent TEXT DEFAULT 'default', agents_json TEXT DEFAULT '[]',
+        status TEXT DEFAULT 'active',
+        FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE SET NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_terminal_sessions_project ON terminal_sessions(project_id);
+      CREATE INDEX IF NOT EXISTS idx_terminal_sessions_status ON terminal_sessions(status);
+    `);
+        db.prepare('INSERT INTO schema_version (version) VALUES (?)').run(4);
+    }
+    if (fromVersion < 5 && toVersion >= 5) {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS file_locks (
+        path TEXT NOT NULL, project_id INTEGER NOT NULL,
+        session_id TEXT NOT NULL, agent_id TEXT NOT NULL,
+        locked_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY (path, project_id),
+        FOREIGN KEY (session_id) REFERENCES terminal_sessions(id) ON DELETE CASCADE,
+        FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+      );
+      CREATE INDEX IF NOT EXISTS idx_file_locks_session ON file_locks(session_id);
+    `);
+        db.prepare('INSERT INTO schema_version (version) VALUES (?)').run(5);
+    }
+    if (fromVersion < 6 && toVersion >= 6) {
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS session_notifications (
+        id TEXT PRIMARY KEY, project_id INTEGER NOT NULL,
+        from_session_id TEXT NOT NULL, to_session_id TEXT,
+        type TEXT NOT NULL, title TEXT NOT NULL,
+        message TEXT, payload_json TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP, read_at DATETIME,
+        FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE,
+        FOREIGN KEY (from_session_id) REFERENCES terminal_sessions(id) ON DELETE CASCADE
+      );
+      CREATE INDEX IF NOT EXISTS idx_session_notifications_project ON session_notifications(project_id);
+      CREATE INDEX IF NOT EXISTS idx_session_notifications_to_session ON session_notifications(to_session_id);
+      CREATE INDEX IF NOT EXISTS idx_session_notifications_unread ON session_notifications(read_at);
+    `);
+        db.prepare('INSERT INTO schema_version (version) VALUES (?)').run(6);
+    }
+}

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

@@ -0,0 +1,19 @@
+/**
+ * SQLite Document Repository — Concrete implementation of IDocumentRepository.
+ */
+import type Database from 'better-sqlite3';
+import type { IDocumentRepository } from '../repositories.js';
+import type { ProjectDocument, DocumentType, CreateDocumentInput, UpdateDocumentInput } from '../types.js';
+export declare class SQLiteDocumentRepository implements IDocumentRepository {
+    private readonly db;
+    constructor(db: Database.Database);
+    upsert(input: CreateDocumentInput): Promise<ProjectDocument>;
+    create(input: CreateDocumentInput): Promise<ProjectDocument>;
+    getById(id: number): Promise<ProjectDocument | null>;
+    getByType(projectId: number, docType: DocumentType): Promise<ProjectDocument | null>;
+    listByProject(projectId: number): Promise<ProjectDocument[]>;
+    update(id: number, input: UpdateDocumentInput): Promise<ProjectDocument | null>;
+    delete(id: number): Promise<boolean>;
+    deleteByType(projectId: number, docType: DocumentType): Promise<boolean>;
+    getTypeCounts(projectId: number): Promise<Record<DocumentType, number>>;
+}

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

@@ -0,0 +1,126 @@
+/**
+ * SQLite Document Repository — Concrete implementation of IDocumentRepository.
+ */
+function recordToDocument(record) {
+    return {
+        id: record.id,
+        projectId: record.project_id,
+        docType: record.doc_type,
+        title: record.title,
+        content: record.content,
+        createdAt: new Date(record.created_at),
+        updatedAt: new Date(record.updated_at),
+        status: record.status,
+        workItemId: record.work_item_id,
+    };
+}
+export class SQLiteDocumentRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    upsert(input) {
+        const now = new Date().toISOString();
+        const existing = this.db
+            .prepare('SELECT * FROM project_documents WHERE project_id = ? AND doc_type = ?')
+            .get(input.project_id, input.doc_type);
+        if (existing) {
+            this.db
+                .prepare('UPDATE project_documents SET title = ?, content = ?, updated_at = ? WHERE id = ?')
+                .run(input.title, input.content, now, existing.id);
+            const record = this.db
+                .prepare('SELECT * FROM project_documents WHERE id = ?')
+                .get(existing.id);
+            return Promise.resolve(recordToDocument(record));
+        }
+        const result = this.db
+            .prepare(`INSERT INTO project_documents (project_id, doc_type, title, content, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?)`)
+            .run(input.project_id, input.doc_type, input.title, input.content, now, now);
+        const record = this.db
+            .prepare('SELECT * FROM project_documents WHERE id = ?')
+            .get(Number(result.lastInsertRowid));
+        return Promise.resolve(recordToDocument(record));
+    }
+    create(input) {
+        const now = new Date().toISOString();
+        const result = this.db
+            .prepare(`INSERT INTO project_documents (project_id, doc_type, title, content, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?)`)
+            .run(input.project_id, input.doc_type, input.title, input.content, now, now);
+        const record = this.db
+            .prepare('SELECT * FROM project_documents WHERE id = ?')
+            .get(Number(result.lastInsertRowid));
+        return Promise.resolve(recordToDocument(record));
+    }
+    getById(id) {
+        const record = this.db.prepare('SELECT * FROM project_documents WHERE id = ?').get(id);
+        return Promise.resolve(record ? recordToDocument(record) : null);
+    }
+    getByType(projectId, docType) {
+        const record = this.db
+            .prepare('SELECT * FROM project_documents WHERE project_id = ? AND doc_type = ?')
+            .get(projectId, docType);
+        return Promise.resolve(record ? recordToDocument(record) : null);
+    }
+    listByProject(projectId) {
+        const records = this.db
+            .prepare(`SELECT * FROM project_documents WHERE project_id = ?
+         ORDER BY
+           CASE doc_type
+             WHEN 'prd' THEN 1 WHEN 'architecture' THEN 2
+             WHEN 'design' THEN 3 WHEN 'notes' THEN 4
+             WHEN 'plan' THEN 5 ELSE 6
+           END, created_at ASC`)
+            .all(projectId);
+        return Promise.resolve(records.map(recordToDocument));
+    }
+    update(id, input) {
+        const updates = [];
+        const params = [];
+        if (input.title !== undefined) {
+            updates.push('title = ?');
+            params.push(input.title);
+        }
+        if (input.content !== undefined) {
+            updates.push('content = ?');
+            params.push(input.content);
+        }
+        if (updates.length === 0)
+            return this.getById(id);
+        updates.push('updated_at = ?');
+        params.push(new Date().toISOString());
+        params.push(id);
+        this.db
+            .prepare(`UPDATE project_documents SET ${updates.join(', ')} WHERE id = ?`)
+            .run(...params);
+        return this.getById(id);
+    }
+    delete(id) {
+        const result = this.db.prepare('DELETE FROM project_documents WHERE id = ?').run(id);
+        return Promise.resolve(result.changes > 0);
+    }
+    deleteByType(projectId, docType) {
+        const result = this.db
+            .prepare('DELETE FROM project_documents WHERE project_id = ? AND doc_type = ?')
+            .run(projectId, docType);
+        return Promise.resolve(result.changes > 0);
+    }
+    getTypeCounts(projectId) {
+        const results = this.db
+            .prepare('SELECT doc_type, COUNT(*) as count FROM project_documents WHERE project_id = ? GROUP BY doc_type')
+            .all(projectId);
+        const counts = {
+            prd: 0,
+            architecture: 0,
+            design: 0,
+            notes: 0,
+            plan: 0,
+            'app-model': 0,
+        };
+        for (const row of results) {
+            counts[row.doc_type] = row.count;
+        }
+        return Promise.resolve(counts);
+    }
+}

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

@@ -0,0 +1,40 @@
+/**
+ * SQLite Platform Repositories — Concrete implementations of platform interfaces.
+ *
+ * Requires better-sqlite3 as a peer dependency.
+ * Both CLI and Desktop import from this module to avoid code duplication.
+ *
+ * @example
+ * ```typescript
+ * import { createSQLiteRepositories, getDatabase } from '@compilr-dev/sdk/sqlite';
+ * // or from the main entry:
+ * import { createSQLiteRepositories, getDatabase } from '@compilr-dev/sdk';
+ *
+ * const db = getDatabase('~/.compilr-dev/projects.db');
+ * const repos = createSQLiteRepositories(db);
+ * // repos.projects, repos.workItems, repos.documents, repos.plans
+ * ```
+ */
+import type Database from 'better-sqlite3';
+import { type ProjectDeleteHooks } from './project-repository.js';
+import type { IProjectRepository, IWorkItemRepository, IDocumentRepository, IPlanRepository } from '../repositories.js';
+export interface SQLiteRepositories {
+    projects: IProjectRepository;
+    workItems: IWorkItemRepository;
+    documents: IDocumentRepository;
+    plans: IPlanRepository;
+}
+export interface CreateSQLiteRepositoriesOptions {
+    projectDeleteHooks?: ProjectDeleteHooks;
+}
+/**
+ * Create all 4 platform repositories backed by a single SQLite database.
+ */
+export declare function createSQLiteRepositories(db: Database.Database, options?: CreateSQLiteRepositoriesOptions): SQLiteRepositories;
+export { SQLiteProjectRepository, type ProjectDeleteHooks } from './project-repository.js';
+export { SQLiteWorkItemRepository } from './work-item-repository.js';
+export { SQLiteDocumentRepository } from './document-repository.js';
+export { SQLitePlanRepository } from './plan-repository.js';
+export { getDatabase, closeDatabase, closeAllDatabases, databaseExists } from './db.js';
+export { SCHEMA_VERSION, SCHEMA_SQL } from './schema.js';
+export type { ProjectRecord, WorkItemRecord, ProjectDocumentRecord } from './schema.js';

package/dist/platform/sqlite/index.js

@@ -0,0 +1,41 @@
+/**
+ * SQLite Platform Repositories — Concrete implementations of platform interfaces.
+ *
+ * Requires better-sqlite3 as a peer dependency.
+ * Both CLI and Desktop import from this module to avoid code duplication.
+ *
+ * @example
+ * ```typescript
+ * import { createSQLiteRepositories, getDatabase } from '@compilr-dev/sdk/sqlite';
+ * // or from the main entry:
+ * import { createSQLiteRepositories, getDatabase } from '@compilr-dev/sdk';
+ *
+ * const db = getDatabase('~/.compilr-dev/projects.db');
+ * const repos = createSQLiteRepositories(db);
+ * // repos.projects, repos.workItems, repos.documents, repos.plans
+ * ```
+ */
+import { SQLiteProjectRepository } from './project-repository.js';
+import { SQLiteWorkItemRepository } from './work-item-repository.js';
+import { SQLiteDocumentRepository } from './document-repository.js';
+import { SQLitePlanRepository } from './plan-repository.js';
+/**
+ * Create all 4 platform repositories backed by a single SQLite database.
+ */
+export function createSQLiteRepositories(db, options) {
+    return {
+        projects: new SQLiteProjectRepository(db, options?.projectDeleteHooks),
+        workItems: new SQLiteWorkItemRepository(db),
+        documents: new SQLiteDocumentRepository(db),
+        plans: new SQLitePlanRepository(db),
+    };
+}
+// Re-export classes for advanced usage
+export { SQLiteProjectRepository } from './project-repository.js';
+export { SQLiteWorkItemRepository } from './work-item-repository.js';
+export { SQLiteDocumentRepository } from './document-repository.js';
+export { SQLitePlanRepository } from './plan-repository.js';
+// Re-export database utilities
+export { getDatabase, closeDatabase, closeAllDatabases, databaseExists } from './db.js';
+// Re-export schema (for consumers that need direct access)
+export { SCHEMA_VERSION, SCHEMA_SQL } from './schema.js';

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 });
+    }
+}