@kjerneverk/riotplan-format 1.0.0-dev.0

package/dist/index.js

@@ -0,0 +1,1791 @@
+import Database from "better-sqlite3";
+import { readFileSync, existsSync, statSync, unlinkSync, rmSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join, extname } from "node:path";
+import { randomUUID } from "node:crypto";
+const DEFAULT_SQLITE_CONFIG = {
+  walMode: true,
+  pragmas: {
+    "journal_mode": "WAL",
+    "synchronous": "NORMAL",
+    "foreign_keys": true,
+    "temp_store": "memory"
+  },
+  extension: ".plan"
+};
+const DEFAULT_DIRECTORY_CONFIG = {
+  usePlanSubdir: true,
+  permissions: "0755"
+};
+const DEFAULT_FORMAT_CONFIG = {
+  defaultFormat: "directory",
+  sqlite: DEFAULT_SQLITE_CONFIG,
+  directory: DEFAULT_DIRECTORY_CONFIG
+};
+function mergeFormatConfig(userConfig) {
+  if (!userConfig) {
+    return DEFAULT_FORMAT_CONFIG;
+  }
+  return {
+    defaultFormat: userConfig.defaultFormat ?? DEFAULT_FORMAT_CONFIG.defaultFormat,
+    sqlite: {
+      ...DEFAULT_SQLITE_CONFIG,
+      ...userConfig.sqlite,
+      pragmas: {
+        ...DEFAULT_SQLITE_CONFIG.pragmas,
+        ...userConfig.sqlite?.pragmas
+      }
+    },
+    directory: {
+      ...DEFAULT_DIRECTORY_CONFIG,
+      ...userConfig.directory
+    }
+  };
+}
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = dirname(__filename$1);
+class SqliteStorageProvider {
+  format = "sqlite";
+  path;
+  db;
+  planId = null;
+  constructor(planPath) {
+    this.path = planPath;
+    this.db = new Database(planPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+  }
+  /**
+   * Initialize the database with schema
+   */
+  initializeSchema() {
+    const schemaPath = join(__dirname$1, "schema.sql");
+    const schema = readFileSync(schemaPath, "utf-8");
+    this.db.exec(schema);
+  }
+  /**
+   * Get the plan ID, loading it if necessary
+   */
+  getPlanId() {
+    if (this.planId !== null) {
+      return this.planId;
+    }
+    const row = this.db.prepare("SELECT id FROM plans LIMIT 1").get();
+    if (!row) {
+      throw new Error("No plan found in database");
+    }
+    this.planId = row.id;
+    return this.planId;
+  }
+  // ==================== Core Operations ====================
+  async exists() {
+    try {
+      const row = this.db.prepare("SELECT COUNT(*) as count FROM plans").get();
+      return row.count > 0;
+    } catch {
+      return false;
+    }
+  }
+  async initialize(metadata) {
+    try {
+      this.initializeSchema();
+      const stmt = this.db.prepare(`
+                INSERT INTO plans (code, name, description, stage, created_at, updated_at, schema_version)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+            `);
+      const result = stmt.run(
+        metadata.id,
+        metadata.name,
+        metadata.description || null,
+        metadata.stage,
+        metadata.createdAt,
+        metadata.updatedAt,
+        metadata.schemaVersion
+      );
+      this.planId = result.lastInsertRowid;
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to initialize plan"
+      };
+    }
+  }
+  async close() {
+    this.db.close();
+  }
+  // ==================== Metadata Operations ====================
+  async getMetadata() {
+    try {
+      const row = this.db.prepare(`
+                SELECT code, name, description, stage, created_at, updated_at, schema_version
+                FROM plans WHERE id = ?
+            `).get(this.getPlanId());
+      if (!row) {
+        return { success: false, error: "Plan not found" };
+      }
+      return {
+        success: true,
+        data: {
+          id: row.code,
+          name: row.name,
+          description: row.description || void 0,
+          stage: row.stage,
+          createdAt: row.created_at,
+          updatedAt: row.updated_at,
+          schemaVersion: row.schema_version
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get metadata"
+      };
+    }
+  }
+  async updateMetadata(metadata) {
+    try {
+      const updates = [];
+      const values = [];
+      if (metadata.name !== void 0) {
+        updates.push("name = ?");
+        values.push(metadata.name);
+      }
+      if (metadata.description !== void 0) {
+        updates.push("description = ?");
+        values.push(metadata.description);
+      }
+      if (metadata.stage !== void 0) {
+        updates.push("stage = ?");
+        values.push(metadata.stage);
+      }
+      updates.push("updated_at = ?");
+      values.push((/* @__PURE__ */ new Date()).toISOString());
+      values.push(this.getPlanId());
+      this.db.prepare(`UPDATE plans SET ${updates.join(", ")} WHERE id = ?`).run(...values);
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to update metadata"
+      };
+    }
+  }
+  // ==================== Step Operations ====================
+  async getSteps() {
+    try {
+      const rows = this.db.prepare(`
+                SELECT number, code, title, description, status, started_at, completed_at, content
+                FROM plan_steps WHERE plan_id = ? ORDER BY number
+            `).all(this.getPlanId());
+      const steps = rows.map((row) => ({
+        number: row.number,
+        code: row.code,
+        title: row.title,
+        description: row.description || void 0,
+        status: row.status,
+        startedAt: row.started_at || void 0,
+        completedAt: row.completed_at || void 0,
+        content: row.content
+      }));
+      return { success: true, data: steps };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get steps"
+      };
+    }
+  }
+  async getStep(number) {
+    try {
+      const row = this.db.prepare(`
+                SELECT number, code, title, description, status, started_at, completed_at, content
+                FROM plan_steps WHERE plan_id = ? AND number = ?
+            `).get(this.getPlanId(), number);
+      if (!row) {
+        return { success: true, data: null };
+      }
+      return {
+        success: true,
+        data: {
+          number: row.number,
+          code: row.code,
+          title: row.title,
+          description: row.description || void 0,
+          status: row.status,
+          startedAt: row.started_at || void 0,
+          completedAt: row.completed_at || void 0,
+          content: row.content
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get step"
+      };
+    }
+  }
+  async addStep(step) {
+    try {
+      this.db.prepare(`
+                INSERT INTO plan_steps (plan_id, number, code, title, description, status, started_at, completed_at, content)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            `).run(
+        this.getPlanId(),
+        step.number,
+        step.code,
+        step.title,
+        step.description || null,
+        step.status,
+        step.startedAt || null,
+        step.completedAt || null,
+        step.content
+      );
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to add step"
+      };
+    }
+  }
+  async updateStep(number, updates) {
+    try {
+      const fields = [];
+      const values = [];
+      if (updates.code !== void 0) {
+        fields.push("code = ?");
+        values.push(updates.code);
+      }
+      if (updates.title !== void 0) {
+        fields.push("title = ?");
+        values.push(updates.title);
+      }
+      if (updates.description !== void 0) {
+        fields.push("description = ?");
+        values.push(updates.description);
+      }
+      if (updates.status !== void 0) {
+        fields.push("status = ?");
+        values.push(updates.status);
+      }
+      if (updates.startedAt !== void 0) {
+        fields.push("started_at = ?");
+        values.push(updates.startedAt);
+      }
+      if (updates.completedAt !== void 0) {
+        fields.push("completed_at = ?");
+        values.push(updates.completedAt);
+      }
+      if (updates.content !== void 0) {
+        fields.push("content = ?");
+        values.push(updates.content);
+      }
+      if (fields.length === 0) {
+        return { success: true };
+      }
+      values.push(this.getPlanId(), number);
+      this.db.prepare(`UPDATE plan_steps SET ${fields.join(", ")} WHERE plan_id = ? AND number = ?`).run(...values);
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to update step"
+      };
+    }
+  }
+  async deleteStep(number) {
+    try {
+      this.db.prepare("DELETE FROM plan_steps WHERE plan_id = ? AND number = ?").run(this.getPlanId(), number);
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to delete step"
+      };
+    }
+  }
+  // ==================== File Operations ====================
+  async getFiles() {
+    try {
+      const rows = this.db.prepare(`
+                SELECT file_type, filename, content, created_at, updated_at
+                FROM plan_files WHERE plan_id = ?
+            `).all(this.getPlanId());
+      const files = rows.map((row) => ({
+        type: row.file_type,
+        filename: row.filename,
+        content: row.content,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at
+      }));
+      return { success: true, data: files };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get files"
+      };
+    }
+  }
+  async getFile(type, filename) {
+    try {
+      const row = this.db.prepare(`
+                SELECT file_type, filename, content, created_at, updated_at
+                FROM plan_files WHERE plan_id = ? AND file_type = ? AND filename = ?
+            `).get(this.getPlanId(), type, filename);
+      if (!row) {
+        return { success: true, data: null };
+      }
+      return {
+        success: true,
+        data: {
+          type: row.file_type,
+          filename: row.filename,
+          content: row.content,
+          createdAt: row.created_at,
+          updatedAt: row.updated_at
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get file"
+      };
+    }
+  }
+  async saveFile(file) {
+    try {
+      this.db.prepare(`
+                INSERT INTO plan_files (plan_id, file_type, filename, content, created_at, updated_at)
+                VALUES (?, ?, ?, ?, ?, ?)
+                ON CONFLICT(plan_id, file_type, filename) DO UPDATE SET
+                    content = excluded.content,
+                    updated_at = excluded.updated_at
+            `).run(
+        this.getPlanId(),
+        file.type,
+        file.filename,
+        file.content,
+        file.createdAt,
+        file.updatedAt
+      );
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to save file"
+      };
+    }
+  }
+  async deleteFile(type, filename) {
+    try {
+      this.db.prepare("DELETE FROM plan_files WHERE plan_id = ? AND file_type = ? AND filename = ?").run(this.getPlanId(), type, filename);
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to delete file"
+      };
+    }
+  }
+  // ==================== Timeline Operations ====================
+  async getTimelineEvents(options) {
+    try {
+      let sql = "SELECT id, timestamp, event_type, data FROM timeline_events WHERE plan_id = ?";
+      const params = [this.getPlanId()];
+      if (options?.since) {
+        sql += " AND timestamp >= ?";
+        params.push(options.since);
+      }
+      if (options?.type) {
+        sql += " AND event_type = ?";
+        params.push(options.type);
+      }
+      sql += " ORDER BY timestamp DESC";
+      if (options?.limit) {
+        sql += " LIMIT ?";
+        params.push(options.limit);
+      }
+      const rows = this.db.prepare(sql).all(...params);
+      const events = rows.map((row) => ({
+        id: row.id,
+        timestamp: row.timestamp,
+        type: row.event_type,
+        data: JSON.parse(row.data)
+      }));
+      return { success: true, data: events };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get timeline events"
+      };
+    }
+  }
+  async addTimelineEvent(event) {
+    try {
+      this.db.prepare(`
+                INSERT INTO timeline_events (id, plan_id, timestamp, event_type, data)
+                VALUES (?, ?, ?, ?, ?)
+            `).run(
+        event.id || randomUUID(),
+        this.getPlanId(),
+        event.timestamp,
+        event.type,
+        JSON.stringify(event.data)
+      );
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to add timeline event"
+      };
+    }
+  }
+  // ==================== Evidence Operations ====================
+  async getEvidence() {
+    try {
+      const rows = this.db.prepare(`
+                SELECT id, description, source, source_url, gathering_method, content, file_path, 
+                       relevance_score, original_query, summary, created_at
+                FROM evidence_records WHERE plan_id = ?
+            `).all(this.getPlanId());
+      const evidence = rows.map((row) => ({
+        id: row.id,
+        description: row.description,
+        source: row.source || void 0,
+        sourceUrl: row.source_url || void 0,
+        gatheringMethod: row.gathering_method,
+        content: row.content || void 0,
+        filePath: row.file_path || void 0,
+        relevanceScore: row.relevance_score ?? void 0,
+        originalQuery: row.original_query || void 0,
+        summary: row.summary || void 0,
+        createdAt: row.created_at
+      }));
+      return { success: true, data: evidence };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get evidence"
+      };
+    }
+  }
+  async addEvidence(evidence) {
+    try {
+      this.db.prepare(`
+                INSERT INTO evidence_records (id, plan_id, description, source, source_url, gathering_method, 
+                                              content, file_path, relevance_score, original_query, summary, created_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            `).run(
+        evidence.id || randomUUID(),
+        this.getPlanId(),
+        evidence.description,
+        evidence.source || null,
+        evidence.sourceUrl || null,
+        evidence.gatheringMethod || null,
+        evidence.content || null,
+        evidence.filePath || null,
+        evidence.relevanceScore ?? null,
+        evidence.originalQuery || null,
+        evidence.summary || null,
+        evidence.createdAt
+      );
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to add evidence"
+      };
+    }
+  }
+  // ==================== Feedback Operations ====================
+  async getFeedback() {
+    try {
+      const rows = this.db.prepare(`
+                SELECT id, title, platform, content, participants, created_at
+                FROM feedback_records WHERE plan_id = ?
+            `).all(this.getPlanId());
+      const feedback = rows.map((row) => ({
+        id: row.id,
+        title: row.title || void 0,
+        platform: row.platform || void 0,
+        content: row.content,
+        participants: row.participants ? JSON.parse(row.participants) : void 0,
+        createdAt: row.created_at
+      }));
+      return { success: true, data: feedback };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get feedback"
+      };
+    }
+  }
+  async addFeedback(feedback) {
+    try {
+      this.db.prepare(`
+                INSERT INTO feedback_records (id, plan_id, title, platform, content, participants, created_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+            `).run(
+        feedback.id || randomUUID(),
+        this.getPlanId(),
+        feedback.title || null,
+        feedback.platform || null,
+        feedback.content,
+        feedback.participants ? JSON.stringify(feedback.participants) : null,
+        feedback.createdAt
+      );
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to add feedback"
+      };
+    }
+  }
+  // ==================== Checkpoint Operations ====================
+  async getCheckpoints() {
+    try {
+      const rows = this.db.prepare(`
+                SELECT name, message, created_at, snapshot
+                FROM checkpoints WHERE plan_id = ? ORDER BY created_at DESC
+            `).all(this.getPlanId());
+      const checkpoints = rows.map((row) => ({
+        name: row.name,
+        message: row.message,
+        createdAt: row.created_at,
+        snapshot: JSON.parse(row.snapshot)
+      }));
+      return { success: true, data: checkpoints };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get checkpoints"
+      };
+    }
+  }
+  async getCheckpoint(name) {
+    try {
+      const row = this.db.prepare(`
+                SELECT name, message, created_at, snapshot
+                FROM checkpoints WHERE plan_id = ? AND name = ?
+            `).get(this.getPlanId(), name);
+      if (!row) {
+        return { success: true, data: null };
+      }
+      return {
+        success: true,
+        data: {
+          name: row.name,
+          message: row.message,
+          createdAt: row.created_at,
+          snapshot: JSON.parse(row.snapshot)
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get checkpoint"
+      };
+    }
+  }
+  async createCheckpoint(checkpoint) {
+    try {
+      this.db.prepare(`
+                INSERT INTO checkpoints (plan_id, name, message, created_at, snapshot)
+                VALUES (?, ?, ?, ?, ?)
+                ON CONFLICT(plan_id, name) DO UPDATE SET
+                    message = excluded.message,
+                    created_at = excluded.created_at,
+                    snapshot = excluded.snapshot
+            `).run(
+        this.getPlanId(),
+        checkpoint.name,
+        checkpoint.message,
+        checkpoint.createdAt,
+        JSON.stringify(checkpoint.snapshot)
+      );
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to create checkpoint"
+      };
+    }
+  }
+  async restoreCheckpoint(name) {
+    try {
+      const checkpointResult = await this.getCheckpoint(name);
+      if (!checkpointResult.success || !checkpointResult.data) {
+        return { success: false, error: `Checkpoint not found: ${name}` };
+      }
+      const snapshot = checkpointResult.data.snapshot;
+      const planId = this.getPlanId();
+      const restore = this.db.transaction(() => {
+        this.db.prepare(`
+                    UPDATE plans SET name = ?, description = ?, stage = ?, updated_at = ?
+                    WHERE id = ?
+                `).run(
+          snapshot.metadata.name,
+          snapshot.metadata.description || null,
+          snapshot.metadata.stage,
+          (/* @__PURE__ */ new Date()).toISOString(),
+          planId
+        );
+        for (const step of snapshot.steps) {
+          this.db.prepare(`
+                        UPDATE plan_steps SET status = ?, started_at = ?, completed_at = ?
+                        WHERE plan_id = ? AND number = ?
+                    `).run(
+            step.status,
+            step.startedAt || null,
+            step.completedAt || null,
+            planId,
+            step.number
+          );
+        }
+        for (const file of snapshot.files) {
+          this.db.prepare(`
+                        INSERT INTO plan_files (plan_id, file_type, filename, content, created_at, updated_at)
+                        VALUES (?, ?, ?, ?, ?, ?)
+                        ON CONFLICT(plan_id, file_type, filename) DO UPDATE SET
+                            content = excluded.content,
+                            updated_at = excluded.updated_at
+                    `).run(
+            planId,
+            file.type,
+            file.filename,
+            file.content,
+            (/* @__PURE__ */ new Date()).toISOString(),
+            (/* @__PURE__ */ new Date()).toISOString()
+          );
+        }
+      });
+      restore();
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to restore checkpoint"
+      };
+    }
+  }
+  // ==================== Search Operations ====================
+  async search(query) {
+    try {
+      const results = [];
+      const planId = this.getPlanId();
+      const searchPattern = `%${query}%`;
+      const stepRows = this.db.prepare(`
+                SELECT number, title, content FROM plan_steps
+                WHERE plan_id = ? AND (title LIKE ? OR content LIKE ?)
+            `).all(planId, searchPattern, searchPattern);
+      for (const row of stepRows) {
+        results.push({
+          type: "step",
+          id: String(row.number),
+          snippet: this.extractSnippet(row.content, query),
+          score: this.calculateScore(row.content, query)
+        });
+      }
+      const fileRows = this.db.prepare(`
+                SELECT file_type, filename, content FROM plan_files
+                WHERE plan_id = ? AND content LIKE ?
+            `).all(planId, searchPattern);
+      for (const row of fileRows) {
+        results.push({
+          type: "file",
+          id: row.filename,
+          snippet: this.extractSnippet(row.content, query),
+          score: this.calculateScore(row.content, query)
+        });
+      }
+      const evidenceRows = this.db.prepare(`
+                SELECT id, description, content FROM evidence_records
+                WHERE plan_id = ? AND (description LIKE ? OR content LIKE ?)
+            `).all(planId, searchPattern, searchPattern);
+      for (const row of evidenceRows) {
+        results.push({
+          type: "evidence",
+          id: row.id,
+          snippet: this.extractSnippet(row.content || row.description, query),
+          score: this.calculateScore(row.content || row.description, query)
+        });
+      }
+      results.sort((a, b) => b.score - a.score);
+      return { success: true, data: results };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to search"
+      };
+    }
+  }
+  extractSnippet(content, query) {
+    const lowerContent = content.toLowerCase();
+    const lowerQuery = query.toLowerCase();
+    const index = lowerContent.indexOf(lowerQuery);
+    if (index === -1) {
+      return content.slice(0, 100) + "...";
+    }
+    const start = Math.max(0, index - 50);
+    const end = Math.min(content.length, index + query.length + 50);
+    let snippet = content.slice(start, end);
+    if (start > 0) snippet = "..." + snippet;
+    if (end < content.length) snippet = snippet + "...";
+    return snippet;
+  }
+  calculateScore(content, query) {
+    const lowerContent = content.toLowerCase();
+    const lowerQuery = query.toLowerCase();
+    let count = 0;
+    let pos = 0;
+    while ((pos = lowerContent.indexOf(lowerQuery, pos)) !== -1) {
+      count++;
+      pos += lowerQuery.length;
+    }
+    return Math.min(1, count / 10);
+  }
+  // ==================== Utility Methods ====================
+  /**
+   * Create a snapshot of the current plan state for checkpoints
+   */
+  async createSnapshot() {
+    const metadataResult = await this.getMetadata();
+    const stepsResult = await this.getSteps();
+    const filesResult = await this.getFiles();
+    if (!metadataResult.success || !metadataResult.data) {
+      throw new Error("Failed to get metadata for snapshot");
+    }
+    return {
+      metadata: metadataResult.data,
+      steps: (stepsResult.data || []).map((s) => ({
+        number: s.number,
+        status: s.status,
+        startedAt: s.startedAt,
+        completedAt: s.completedAt
+      })),
+      files: (filesResult.data || []).map((f) => ({
+        type: f.type,
+        filename: f.filename,
+        content: f.content
+      }))
+    };
+  }
+}
+function createSqliteProvider(planPath) {
+  return new SqliteStorageProvider(planPath);
+}
+class DirectoryStorageProvider {
+  format = "directory";
+  path;
+  constructor(planPath) {
+    this.path = planPath;
+  }
+  async exists() {
+    throw new Error("DirectoryStorageProvider.exists() not implemented - use main riotplan package");
+  }
+  async initialize(_metadata) {
+    throw new Error("DirectoryStorageProvider.initialize() not implemented - use main riotplan package");
+  }
+  async close() {
+  }
+  // Metadata operations
+  async getMetadata() {
+    throw new Error("DirectoryStorageProvider.getMetadata() not implemented - use main riotplan package");
+  }
+  async updateMetadata(_updates) {
+    throw new Error("DirectoryStorageProvider.updateMetadata() not implemented - use main riotplan package");
+  }
+  // Step operations
+  async getSteps() {
+    throw new Error("DirectoryStorageProvider.getSteps() not implemented - use main riotplan package");
+  }
+  async getStep(_number) {
+    throw new Error("DirectoryStorageProvider.getStep() not implemented - use main riotplan package");
+  }
+  async addStep(_step) {
+    throw new Error("DirectoryStorageProvider.addStep() not implemented - use main riotplan package");
+  }
+  async updateStep(_number, _updates) {
+    throw new Error("DirectoryStorageProvider.updateStep() not implemented - use main riotplan package");
+  }
+  async deleteStep(_number) {
+    throw new Error("DirectoryStorageProvider.deleteStep() not implemented - use main riotplan package");
+  }
+  // File operations
+  async getFiles() {
+    throw new Error("DirectoryStorageProvider.getFiles() not implemented - use main riotplan package");
+  }
+  async getFile(_type, _filename) {
+    throw new Error("DirectoryStorageProvider.getFile() not implemented - use main riotplan package");
+  }
+  async saveFile(_file) {
+    throw new Error("DirectoryStorageProvider.saveFile() not implemented - use main riotplan package");
+  }
+  async deleteFile(_type, _filename) {
+    throw new Error("DirectoryStorageProvider.deleteFile() not implemented - use main riotplan package");
+  }
+  // Timeline operations
+  async getTimelineEvents() {
+    throw new Error("DirectoryStorageProvider.getTimelineEvents() not implemented - use main riotplan package");
+  }
+  async addTimelineEvent(_event) {
+    throw new Error("DirectoryStorageProvider.addTimelineEvent() not implemented - use main riotplan package");
+  }
+  // Evidence operations
+  async getEvidence() {
+    throw new Error("DirectoryStorageProvider.getEvidence() not implemented - use main riotplan package");
+  }
+  async addEvidence(_evidence) {
+    throw new Error("DirectoryStorageProvider.addEvidence() not implemented - use main riotplan package");
+  }
+  // Feedback operations
+  async getFeedback() {
+    throw new Error("DirectoryStorageProvider.getFeedback() not implemented - use main riotplan package");
+  }
+  async addFeedback(_feedback) {
+    throw new Error("DirectoryStorageProvider.addFeedback() not implemented - use main riotplan package");
+  }
+  // Checkpoint operations
+  async getCheckpoints() {
+    throw new Error("DirectoryStorageProvider.getCheckpoints() not implemented - use main riotplan package");
+  }
+  async getCheckpoint(_name) {
+    throw new Error("DirectoryStorageProvider.getCheckpoint() not implemented - use main riotplan package");
+  }
+  async createCheckpoint(_checkpoint) {
+    throw new Error("DirectoryStorageProvider.createCheckpoint() not implemented - use main riotplan package");
+  }
+  async restoreCheckpoint(_name) {
+    throw new Error("DirectoryStorageProvider.restoreCheckpoint() not implemented - use main riotplan package");
+  }
+  // Search operations
+  async search(_query) {
+    throw new Error("DirectoryStorageProvider.search() not implemented - use main riotplan package");
+  }
+  // Snapshot operations
+  async createSnapshot() {
+    throw new Error("DirectoryStorageProvider.createSnapshot() not implemented - use main riotplan package");
+  }
+}
+function createDirectoryProvider(planPath) {
+  return new DirectoryStorageProvider(planPath);
+}
+const SQLITE_HEADER = Buffer.from("SQLite format 3\0");
+const DIRECTORY_PLAN_MARKERS = [
+  "SUMMARY.md",
+  "STATUS.md",
+  "IDEA.md",
+  "EXECUTION_PLAN.md"
+];
+function detectPlanFormat(planPath) {
+  if (!existsSync(planPath)) {
+    return "unknown";
+  }
+  const stats = statSync(planPath);
+  if (stats.isDirectory()) {
+    for (const marker of DIRECTORY_PLAN_MARKERS) {
+      if (existsSync(join(planPath, marker))) {
+        return "directory";
+      }
+    }
+    const planDir = join(planPath, "plan");
+    if (existsSync(planDir) && statSync(planDir).isDirectory()) {
+      return "directory";
+    }
+    return "unknown";
+  }
+  if (stats.isFile()) {
+    if (hasSqliteHeader(planPath)) {
+      return "sqlite";
+    }
+    if (planPath.endsWith(".plan")) {
+      return "unknown";
+    }
+  }
+  return "unknown";
+}
+function hasSqliteHeader(filePath) {
+  try {
+    const fd = readFileSync(filePath, { flag: "r" });
+    if (fd.length < SQLITE_HEADER.length) {
+      return false;
+    }
+    return fd.subarray(0, SQLITE_HEADER.length).equals(SQLITE_HEADER);
+  } catch {
+    return false;
+  }
+}
+function isSqlitePath(planPath, config) {
+  const extension = config?.sqlite?.extension ?? DEFAULT_FORMAT_CONFIG.sqlite.extension;
+  return planPath.endsWith(extension);
+}
+function isDirectoryPath(planPath) {
+  if (existsSync(planPath)) {
+    return statSync(planPath).isDirectory();
+  }
+  const ext = extname(planPath);
+  return ext === "" || ext === ".";
+}
+function getFormatExtension(format, config) {
+  if (format === "sqlite") {
+    const extension = config?.sqlite?.extension ?? DEFAULT_FORMAT_CONFIG.sqlite.extension;
+    return extension;
+  }
+  return "";
+}
+function ensureFormatExtension(planPath, format, config) {
+  if (format === "sqlite") {
+    const extension = getFormatExtension(format, config);
+    if (!planPath.endsWith(extension)) {
+      return `${planPath}${extension}`;
+    }
+  }
+  return planPath;
+}
+function inferFormatFromPath(planPath, config) {
+  if (existsSync(planPath)) {
+    const detected = detectPlanFormat(planPath);
+    if (detected !== "unknown") {
+      return detected;
+    }
+  }
+  if (isSqlitePath(planPath, config)) {
+    return "sqlite";
+  }
+  if (isDirectoryPath(planPath)) {
+    return "directory";
+  }
+  return config?.defaultFormat ?? DEFAULT_FORMAT_CONFIG.defaultFormat;
+}
+function validatePlanPath(planPath, format, config) {
+  if (!planPath || planPath.trim() === "") {
+    return "Plan path cannot be empty";
+  }
+  if (format === "sqlite") {
+    const extension = getFormatExtension(format, config);
+    if (!planPath.endsWith(extension)) {
+      return `SQLite plan path must end with ${extension}`;
+    }
+  }
+  if (format === "directory") {
+    const ext = extname(planPath);
+    if (ext && ext !== ".") {
+      return `Directory plan path should not have a file extension (got ${ext})`;
+    }
+  }
+  return null;
+}
+function getPlanNameFromPath(planPath, format, config) {
+  let name = planPath;
+  if (format === "sqlite") {
+    const extension = getFormatExtension(format, config);
+    if (name.endsWith(extension)) {
+      name = name.slice(0, -extension.length);
+    }
+  }
+  const parts = name.split(/[/\\]/);
+  return parts[parts.length - 1] || name;
+}
+class DefaultStorageProviderFactory {
+  config;
+  constructor(config) {
+    this.config = mergeFormatConfig(config);
+  }
+  /**
+   * Create a storage provider for the given path
+   * 
+   * @param planPath - Path to the plan
+   * @param options - Optional creation options
+   * @returns A storage provider instance
+   */
+  createProvider(planPath, options) {
+    const format = this.determineFormat(planPath, options?.format);
+    if (format === "sqlite") {
+      const finalPath = ensureFormatExtension(planPath, "sqlite", this.config);
+      return new SqliteStorageProvider(finalPath);
+    }
+    throw new Error(
+      "Directory storage provider is not yet implemented in riotplan-format. Use the main riotplan package for directory-based plans."
+    );
+  }
+  /**
+   * Check if this factory supports the given path
+   * 
+   * @param planPath - Path to check
+   * @returns True if a provider can be created for this path
+   */
+  supportsPath(planPath) {
+    const format = detectPlanFormat(planPath);
+    if (format !== "unknown") {
+      return true;
+    }
+    return isSqlitePath(planPath, this.config) || isDirectoryPath(planPath);
+  }
+  /**
+   * Determine the format to use for a path
+   * 
+   * @param planPath - The plan path
+   * @param forcedFormat - Optional format override
+   * @returns The format to use
+   */
+  determineFormat(planPath, forcedFormat) {
+    if (forcedFormat) {
+      return forcedFormat;
+    }
+    const detected = detectPlanFormat(planPath);
+    if (detected !== "unknown") {
+      return detected;
+    }
+    return inferFormatFromPath(planPath, this.config);
+  }
+  /**
+   * Get the default format from configuration
+   */
+  get defaultFormat() {
+    return this.config.defaultFormat;
+  }
+  /**
+   * Get the SQLite configuration
+   */
+  get sqliteConfig() {
+    return this.config.sqlite;
+  }
+  /**
+   * Get the directory configuration
+   */
+  get directoryConfig() {
+    return this.config.directory;
+  }
+}
+function createStorageFactory(config) {
+  return new DefaultStorageProviderFactory(config);
+}
+function createProvider(planPath, options) {
+  const factory = createStorageFactory(options?.config);
+  return factory.createProvider(planPath, options);
+}
+class MigrationValidator {
+  /**
+   * Validate that target contains all data from source
+   */
+  async validate(source, target) {
+    const errors = [];
+    const warnings = [];
+    const stats = {
+      stepsCompared: 0,
+      filesCompared: 0,
+      timelineEventsCompared: 0,
+      evidenceCompared: 0,
+      feedbackCompared: 0
+    };
+    await this.validateMetadata(source, target, errors);
+    const stepsResult = await this.validateSteps(source, target, errors);
+    stats.stepsCompared = stepsResult;
+    const filesResult = await this.validateFiles(source, target, errors);
+    stats.filesCompared = filesResult;
+    const timelineResult = await this.validateTimeline(source, target, errors, warnings);
+    stats.timelineEventsCompared = timelineResult;
+    const evidenceResult = await this.validateEvidence(source, target, errors);
+    stats.evidenceCompared = evidenceResult;
+    const feedbackResult = await this.validateFeedback(source, target, errors);
+    stats.feedbackCompared = feedbackResult;
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings,
+      stats
+    };
+  }
+  async validateMetadata(source, target, errors) {
+    const sourceResult = await source.getMetadata();
+    const targetResult = await target.getMetadata();
+    if (!sourceResult.success || !sourceResult.data) {
+      errors.push({
+        type: "metadata_difference",
+        path: "metadata",
+        expected: "valid metadata",
+        actual: "failed to read source metadata",
+        message: "Could not read source metadata"
+      });
+      return;
+    }
+    if (!targetResult.success || !targetResult.data) {
+      errors.push({
+        type: "metadata_difference",
+        path: "metadata",
+        expected: "valid metadata",
+        actual: "failed to read target metadata",
+        message: "Could not read target metadata"
+      });
+      return;
+    }
+    const sourceData = sourceResult.data;
+    const targetData = targetResult.data;
+    if (sourceData.id !== targetData.id) {
+      errors.push({
+        type: "metadata_difference",
+        path: "metadata.id",
+        expected: sourceData.id,
+        actual: targetData.id,
+        message: `Plan ID mismatch: expected "${sourceData.id}", got "${targetData.id}"`
+      });
+    }
+    if (sourceData.name !== targetData.name) {
+      errors.push({
+        type: "metadata_difference",
+        path: "metadata.name",
+        expected: sourceData.name,
+        actual: targetData.name,
+        message: `Plan name mismatch: expected "${sourceData.name}", got "${targetData.name}"`
+      });
+    }
+    if (sourceData.stage !== targetData.stage) {
+      errors.push({
+        type: "metadata_difference",
+        path: "metadata.stage",
+        expected: sourceData.stage,
+        actual: targetData.stage,
+        message: `Plan stage mismatch: expected "${sourceData.stage}", got "${targetData.stage}"`
+      });
+    }
+  }
+  async validateSteps(source, target, errors) {
+    const sourceResult = await source.getSteps();
+    const targetResult = await target.getSteps();
+    if (!sourceResult.success || !sourceResult.data) {
+      return 0;
+    }
+    const sourceSteps = sourceResult.data;
+    const targetSteps = targetResult.data || [];
+    for (const sourceStep of sourceSteps) {
+      const targetStep = targetSteps.find((s) => s.number === sourceStep.number);
+      if (!targetStep) {
+        errors.push({
+          type: "missing_step",
+          path: `steps[${sourceStep.number}]`,
+          expected: sourceStep,
+          actual: null,
+          message: `Step ${sourceStep.number} is missing in target`
+        });
+        continue;
+      }
+      if (sourceStep.title !== targetStep.title) {
+        errors.push({
+          type: "content_mismatch",
+          path: `steps[${sourceStep.number}].title`,
+          expected: sourceStep.title,
+          actual: targetStep.title,
+          message: `Step ${sourceStep.number} title mismatch`
+        });
+      }
+      if (sourceStep.status !== targetStep.status) {
+        errors.push({
+          type: "content_mismatch",
+          path: `steps[${sourceStep.number}].status`,
+          expected: sourceStep.status,
+          actual: targetStep.status,
+          message: `Step ${sourceStep.number} status mismatch`
+        });
+      }
+      const sourceContent = sourceStep.content.trim();
+      const targetContent = targetStep.content.trim();
+      if (sourceContent !== targetContent) {
+        errors.push({
+          type: "content_mismatch",
+          path: `steps[${sourceStep.number}].content`,
+          expected: `${sourceContent.length} chars`,
+          actual: `${targetContent.length} chars`,
+          message: `Step ${sourceStep.number} content mismatch`
+        });
+      }
+    }
+    for (const targetStep of targetSteps) {
+      const sourceStep = sourceSteps.find((s) => s.number === targetStep.number);
+      if (!sourceStep) {
+        errors.push({
+          type: "content_mismatch",
+          path: `steps[${targetStep.number}]`,
+          expected: null,
+          actual: targetStep,
+          message: `Unexpected step ${targetStep.number} in target`
+        });
+      }
+    }
+    return sourceSteps.length;
+  }
+  async validateFiles(source, target, errors) {
+    const sourceResult = await source.getFiles();
+    const targetResult = await target.getFiles();
+    if (!sourceResult.success || !sourceResult.data) {
+      return 0;
+    }
+    const sourceFiles = sourceResult.data;
+    const targetFiles = targetResult.data || [];
+    for (const sourceFile of sourceFiles) {
+      const targetFile = targetFiles.find(
+        (f) => f.type === sourceFile.type && f.filename === sourceFile.filename
+      );
+      if (!targetFile) {
+        errors.push({
+          type: "missing_file",
+          path: `files[${sourceFile.type}/${sourceFile.filename}]`,
+          expected: sourceFile,
+          actual: null,
+          message: `File ${sourceFile.filename} (${sourceFile.type}) is missing in target`
+        });
+        continue;
+      }
+      const sourceContent = sourceFile.content.trim();
+      const targetContent = targetFile.content.trim();
+      if (sourceContent !== targetContent) {
+        errors.push({
+          type: "content_mismatch",
+          path: `files[${sourceFile.type}/${sourceFile.filename}].content`,
+          expected: `${sourceContent.length} chars`,
+          actual: `${targetContent.length} chars`,
+          message: `File ${sourceFile.filename} content mismatch`
+        });
+      }
+    }
+    return sourceFiles.length;
+  }
+  async validateTimeline(source, target, errors, warnings) {
+    const sourceResult = await source.getTimelineEvents();
+    const targetResult = await target.getTimelineEvents();
+    if (!sourceResult.success || !sourceResult.data) {
+      return 0;
+    }
+    const sourceEvents = sourceResult.data;
+    const targetEvents = targetResult.data || [];
+    for (const sourceEvent of sourceEvents) {
+      const targetEvent = targetEvents.find(
+        (e) => e.type === sourceEvent.type && e.timestamp === sourceEvent.timestamp
+      );
+      if (!targetEvent) {
+        warnings.push(
+          `Timeline event ${sourceEvent.type} at ${sourceEvent.timestamp} not found in target`
+        );
+      }
+    }
+    return sourceEvents.length;
+  }
+  async validateEvidence(source, target, errors) {
+    const sourceResult = await source.getEvidence();
+    const targetResult = await target.getEvidence();
+    if (!sourceResult.success || !sourceResult.data) {
+      return 0;
+    }
+    const sourceEvidence = sourceResult.data;
+    const targetEvidence = targetResult.data || [];
+    for (const sourceItem of sourceEvidence) {
+      const targetItem = targetEvidence.find((e) => e.description === sourceItem.description);
+      if (!targetItem) {
+        errors.push({
+          type: "missing_file",
+          path: `evidence[${sourceItem.id}]`,
+          expected: sourceItem,
+          actual: null,
+          message: `Evidence "${sourceItem.description}" is missing in target`
+        });
+      }
+    }
+    return sourceEvidence.length;
+  }
+  async validateFeedback(source, target, errors) {
+    const sourceResult = await source.getFeedback();
+    const targetResult = await target.getFeedback();
+    if (!sourceResult.success || !sourceResult.data) {
+      return 0;
+    }
+    const sourceFeedback = sourceResult.data;
+    const targetFeedback = targetResult.data || [];
+    for (const sourceItem of sourceFeedback) {
+      const targetItem = targetFeedback.find((f) => f.content === sourceItem.content);
+      if (!targetItem) {
+        errors.push({
+          type: "missing_file",
+          path: `feedback[${sourceItem.id}]`,
+          expected: sourceItem,
+          actual: null,
+          message: `Feedback "${sourceItem.title || sourceItem.id}" is missing in target`
+        });
+      }
+    }
+    return sourceFeedback.length;
+  }
+}
+function createValidator() {
+  return new MigrationValidator();
+}
+class PlanMigrator {
+  validator;
+  constructor() {
+    this.validator = new MigrationValidator();
+  }
+  /**
+   * Migrate a plan from source to target format
+   * 
+   * @param sourcePath - Path to source plan
+   * @param targetPath - Path for target plan
+   * @param sourceProvider - Provider for reading source
+   * @param targetProvider - Provider for writing target
+   * @param options - Migration options
+   */
+  async migrate(sourcePath, targetPath, sourceProvider, targetProvider, options = {}) {
+    const startTime = Date.now();
+    const warnings = [];
+    const stats = {
+      stepsConverted: 0,
+      filesConverted: 0,
+      timelineEventsConverted: 0,
+      evidenceConverted: 0,
+      feedbackConverted: 0,
+      checkpointsConverted: 0
+    };
+    try {
+      const sourceFormat = sourceProvider.format;
+      const targetFormat = targetProvider.format;
+      const targetExists = await targetProvider.exists();
+      if (targetExists && !options.force) {
+        return {
+          success: false,
+          sourceFormat,
+          targetFormat,
+          sourcePath,
+          targetPath,
+          error: `Target already exists: ${targetPath}. Use force option to overwrite.`,
+          warnings,
+          stats,
+          duration: Date.now() - startTime
+        };
+      }
+      this.reportProgress(options.onProgress, {
+        phase: "reading",
+        percentage: 0
+      });
+      const metadataResult = await sourceProvider.getMetadata();
+      if (!metadataResult.success || !metadataResult.data) {
+        return {
+          success: false,
+          sourceFormat,
+          targetFormat,
+          sourcePath,
+          targetPath,
+          error: `Failed to read source metadata: ${metadataResult.error}`,
+          warnings,
+          stats,
+          duration: Date.now() - startTime
+        };
+      }
+      this.reportProgress(options.onProgress, {
+        phase: "writing",
+        percentage: 10,
+        currentItem: "metadata"
+      });
+      const initResult = await targetProvider.initialize(metadataResult.data);
+      if (!initResult.success) {
+        return {
+          success: false,
+          sourceFormat,
+          targetFormat,
+          sourcePath,
+          targetPath,
+          error: `Failed to initialize target: ${initResult.error}`,
+          warnings,
+          stats,
+          duration: Date.now() - startTime
+        };
+      }
+      this.reportProgress(options.onProgress, {
+        phase: "converting",
+        percentage: 20,
+        currentItem: "steps"
+      });
+      stats.stepsConverted = await this.migrateSteps(sourceProvider, targetProvider);
+      this.reportProgress(options.onProgress, {
+        phase: "converting",
+        percentage: 40,
+        currentItem: "files"
+      });
+      stats.filesConverted = await this.migrateFiles(sourceProvider, targetProvider);
+      this.reportProgress(options.onProgress, {
+        phase: "converting",
+        percentage: 60,
+        currentItem: "timeline"
+      });
+      stats.timelineEventsConverted = await this.migrateTimeline(sourceProvider, targetProvider);
+      this.reportProgress(options.onProgress, {
+        phase: "converting",
+        percentage: 70,
+        currentItem: "evidence"
+      });
+      stats.evidenceConverted = await this.migrateEvidence(sourceProvider, targetProvider);
+      this.reportProgress(options.onProgress, {
+        phase: "converting",
+        percentage: 80,
+        currentItem: "feedback"
+      });
+      stats.feedbackConverted = await this.migrateFeedback(sourceProvider, targetProvider);
+      this.reportProgress(options.onProgress, {
+        phase: "converting",
+        percentage: 90,
+        currentItem: "checkpoints"
+      });
+      stats.checkpointsConverted = await this.migrateCheckpoints(sourceProvider, targetProvider);
+      if (options.validate) {
+        this.reportProgress(options.onProgress, {
+          phase: "validating",
+          percentage: 95
+        });
+        const validationResult = await this.validator.validate(sourceProvider, targetProvider);
+        if (!validationResult.valid) {
+          const errorMessages = validationResult.errors.map((e) => e.message).join("; ");
+          return {
+            success: false,
+            sourceFormat,
+            targetFormat,
+            sourcePath,
+            targetPath,
+            error: `Validation failed: ${errorMessages}`,
+            warnings: [...warnings, ...validationResult.warnings],
+            stats,
+            duration: Date.now() - startTime
+          };
+        }
+        warnings.push(...validationResult.warnings);
+      }
+      if (!options.keepSource) {
+        await this.deleteSource(sourcePath, sourceFormat);
+      }
+      this.reportProgress(options.onProgress, {
+        phase: "writing",
+        percentage: 100
+      });
+      return {
+        success: true,
+        sourceFormat,
+        targetFormat,
+        sourcePath,
+        targetPath,
+        warnings,
+        stats,
+        duration: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        success: false,
+        sourceFormat: sourceProvider.format,
+        targetFormat: targetProvider.format,
+        sourcePath,
+        targetPath,
+        error: error instanceof Error ? error.message : "Unknown error during migration",
+        warnings,
+        stats,
+        duration: Date.now() - startTime
+      };
+    }
+  }
+  async migrateSteps(source, target) {
+    const result = await source.getSteps();
+    if (!result.success || !result.data) {
+      return 0;
+    }
+    for (const step of result.data) {
+      await target.addStep(step);
+    }
+    return result.data.length;
+  }
+  async migrateFiles(source, target) {
+    const result = await source.getFiles();
+    if (!result.success || !result.data) {
+      return 0;
+    }
+    for (const file of result.data) {
+      await target.saveFile(file);
+    }
+    return result.data.length;
+  }
+  async migrateTimeline(source, target) {
+    const result = await source.getTimelineEvents();
+    if (!result.success || !result.data) {
+      return 0;
+    }
+    for (const event of result.data) {
+      await target.addTimelineEvent(event);
+    }
+    return result.data.length;
+  }
+  async migrateEvidence(source, target) {
+    const result = await source.getEvidence();
+    if (!result.success || !result.data) {
+      return 0;
+    }
+    for (const evidence of result.data) {
+      await target.addEvidence(evidence);
+    }
+    return result.data.length;
+  }
+  async migrateFeedback(source, target) {
+    const result = await source.getFeedback();
+    if (!result.success || !result.data) {
+      return 0;
+    }
+    for (const feedback of result.data) {
+      await target.addFeedback(feedback);
+    }
+    return result.data.length;
+  }
+  async migrateCheckpoints(source, target) {
+    const result = await source.getCheckpoints();
+    if (!result.success || !result.data) {
+      return 0;
+    }
+    for (const checkpoint of result.data) {
+      await target.createCheckpoint(checkpoint);
+    }
+    return result.data.length;
+  }
+  async deleteSource(sourcePath, format) {
+    if (!existsSync(sourcePath)) {
+      return;
+    }
+    if (format === "sqlite") {
+      unlinkSync(sourcePath);
+      const walPath = sourcePath + "-wal";
+      const shmPath = sourcePath + "-shm";
+      if (existsSync(walPath)) unlinkSync(walPath);
+      if (existsSync(shmPath)) unlinkSync(shmPath);
+    } else {
+      rmSync(sourcePath, { recursive: true, force: true });
+    }
+  }
+  reportProgress(callback, progress) {
+    if (callback) {
+      callback(progress);
+    }
+  }
+}
+function createMigrator() {
+  return new PlanMigrator();
+}
+function generateTargetPath(sourcePath, sourceFormat, targetFormat) {
+  if (targetFormat === "sqlite") {
+    const basePath = sourcePath.replace(/\/$/, "");
+    return ensureFormatExtension(basePath, "sqlite");
+  } else {
+    const basePath = sourcePath.replace(/\.plan$/, "");
+    return basePath + "_migrated";
+  }
+}
+function inferTargetFormat(sourceFormat) {
+  return sourceFormat === "sqlite" ? "directory" : "sqlite";
+}
+async function renderPlanToMarkdown(provider, options = {}) {
+  const result = {
+    files: /* @__PURE__ */ new Map(),
+    steps: /* @__PURE__ */ new Map(),
+    evidence: /* @__PURE__ */ new Map(),
+    feedback: /* @__PURE__ */ new Map()
+  };
+  const metadataResult = await provider.getMetadata();
+  if (metadataResult.success && metadataResult.data) {
+    result.files.set("SUMMARY.md", renderSummary(metadataResult.data, options));
+    result.files.set("STATUS.md", await renderStatus(provider, metadataResult.data));
+  }
+  const filesResult = await provider.getFiles();
+  if (filesResult.success && filesResult.data) {
+    for (const file of filesResult.data) {
+      result.files.set(file.filename, file.content);
+    }
+  }
+  const stepsResult = await provider.getSteps();
+  if (stepsResult.success && stepsResult.data) {
+    for (const step of stepsResult.data) {
+      const filename = formatStepFilename(step);
+      result.steps.set(filename, step.content);
+    }
+  }
+  if (options.includeEvidence !== false) {
+    const evidenceResult = await provider.getEvidence();
+    if (evidenceResult.success && evidenceResult.data) {
+      for (const evidence of evidenceResult.data) {
+        const filename = `${evidence.id}.md`;
+        result.evidence.set(filename, renderEvidence(evidence));
+      }
+    }
+  }
+  if (options.includeFeedback !== false) {
+    const feedbackResult = await provider.getFeedback();
+    if (feedbackResult.success && feedbackResult.data) {
+      for (const feedback of feedbackResult.data) {
+        const filename = `${feedback.id}.md`;
+        result.feedback.set(filename, renderFeedback(feedback));
+      }
+    }
+  }
+  return result;
+}
+function renderSummary(metadata, options) {
+  const lines = [
+    `# ${metadata.name}`,
+    "",
+    "## Overview",
+    "",
+    metadata.description || "_No description provided._",
+    "",
+    "## Metadata",
+    "",
+    `- **ID**: ${metadata.id}`,
+    `- **Stage**: ${metadata.stage}`,
+    `- **Created**: ${metadata.createdAt}`,
+    `- **Updated**: ${metadata.updatedAt}`
+  ];
+  if (options.includeSourceInfo) {
+    lines.push(`- **Schema Version**: ${metadata.schemaVersion}`);
+  }
+  lines.push("", "---", "", `*Generated: ${(/* @__PURE__ */ new Date()).toISOString()}*`);
+  return lines.join("\n");
+}
+async function renderStatus(provider, metadata) {
+  const stepsResult = await provider.getSteps();
+  const steps = stepsResult.data || [];
+  const completed = steps.filter((s) => s.status === "completed").length;
+  const inProgress = steps.filter((s) => s.status === "in_progress").length;
+  const pending = steps.filter((s) => s.status === "pending").length;
+  const total = steps.length;
+  const percentage = total > 0 ? Math.round(completed / total * 100) : 0;
+  const statusEmoji = getStatusEmoji(metadata.stage, inProgress > 0);
+  const lines = [
+    `# ${metadata.name} Status`,
+    "",
+    "## Current State",
+    "",
+    "| Field | Value |",
+    "|-------|-------|",
+    `| **Status** | ${statusEmoji} ${metadata.stage.toUpperCase()} |`,
+    `| **Progress** | ${percentage}% (${completed}/${total} steps) |`,
+    `| **In Progress** | ${inProgress} |`,
+    `| **Pending** | ${pending} |`,
+    `| **Last Updated** | ${metadata.updatedAt.split("T")[0]} |`,
+    "",
+    "## Step Progress",
+    "",
+    "| Step | Name | Status | Started | Completed |",
+    "|------|------|--------|---------|-----------|"
+  ];
+  for (const step of steps) {
+    const statusIcon = getStepStatusIcon(step.status);
+    lines.push(
+      `| ${String(step.number).padStart(2, "0")} | ${step.title} | ${statusIcon} | ${step.startedAt?.split("T")[0] || "-"} | ${step.completedAt?.split("T")[0] || "-"} |`
+    );
+  }
+  lines.push("", "---", "", `*Last updated: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}*`);
+  return lines.join("\n");
+}
+function formatStepFilename(step) {
+  const num = String(step.number).padStart(2, "0");
+  const code = step.code || step.title.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+  return `${num}-${code}.md`;
+}
+function renderEvidence(evidence) {
+  const lines = [
+    "---",
+    `id: ${evidence.id}`,
+    `date: ${evidence.createdAt}`
+  ];
+  if (evidence.source) {
+    lines.push(`source: ${evidence.source}`);
+  }
+  if (evidence.sourceUrl) {
+    lines.push(`url: ${evidence.sourceUrl}`);
+  }
+  if (evidence.gatheringMethod) {
+    lines.push(`gathering_method: ${evidence.gatheringMethod}`);
+  }
+  lines.push("---", "", `# ${evidence.description}`, "");
+  if (evidence.content) {
+    lines.push(evidence.content);
+  }
+  return lines.join("\n");
+}
+function renderFeedback(feedback) {
+  const lines = [
+    "---",
+    `id: ${feedback.id}`,
+    `date: ${feedback.createdAt}`
+  ];
+  if (feedback.title) {
+    lines.push(`title: ${feedback.title}`);
+  }
+  if (feedback.platform) {
+    lines.push(`platform: ${feedback.platform}`);
+  }
+  if (feedback.participants && feedback.participants.length > 0) {
+    lines.push(`participants: [${feedback.participants.join(", ")}]`);
+  }
+  lines.push("---", "");
+  if (feedback.title) {
+    lines.push(`# ${feedback.title}`, "");
+  }
+  lines.push(feedback.content);
+  return lines.join("\n");
+}
+function getStatusEmoji(stage, hasInProgress) {
+  if (stage === "completed") return "✅";
+  if (stage === "cancelled") return "❌";
+  if (hasInProgress) return "🔄";
+  if (stage === "executing") return "🔄";
+  if (stage === "built") return "📋";
+  if (stage === "shaping") return "🔧";
+  return "⬜";
+}
+function getStepStatusIcon(status) {
+  switch (status) {
+    case "completed":
+      return "✅";
+    case "in_progress":
+      return "🔄";
+    case "skipped":
+      return "⏭️";
+    default:
+      return "⬜";
+  }
+}
+const VERSION = "1.0.0-dev.0";
+const SCHEMA_VERSION = 1;
+const PLAN_FILE_EXTENSION = ".plan";
+export {
+  DEFAULT_DIRECTORY_CONFIG,
+  DEFAULT_FORMAT_CONFIG,
+  DEFAULT_SQLITE_CONFIG,
+  DefaultStorageProviderFactory,
+  DirectoryStorageProvider,
+  MigrationValidator,
+  PLAN_FILE_EXTENSION,
+  PlanMigrator,
+  SCHEMA_VERSION,
+  SqliteStorageProvider,
+  VERSION,
+  createDirectoryProvider,
+  createMigrator,
+  createProvider,
+  createSqliteProvider,
+  createStorageFactory,
+  createValidator,
+  detectPlanFormat,
+  ensureFormatExtension,
+  generateTargetPath,
+  getFormatExtension,
+  getPlanNameFromPath,
+  hasSqliteHeader,
+  inferFormatFromPath,
+  inferTargetFormat,
+  isDirectoryPath,
+  isSqlitePath,
+  mergeFormatConfig,
+  renderPlanToMarkdown,
+  validatePlanPath
+};
+//# sourceMappingURL=index.js.map