@groeponline/pi-missions 0.2.0

package/dist/cli/index.js

@@ -0,0 +1,713 @@
+#!/usr/bin/env node
+
+// src/database/index.ts
+import { createRequire } from "module";
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { existsSync, mkdirSync } from "fs";
+import { homedir } from "os";
+var db = null;
+var require2 = createRequire(import.meta.url);
+var databaseDriver = null;
+var CURRENT_SCHEMA_VERSION = 1;
+function describeLoadError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function openSqliteDatabase(filename) {
+  try {
+    const BetterSqlite3 = require2("better-sqlite3");
+    databaseDriver = "better-sqlite3";
+    return new BetterSqlite3(filename);
+  } catch (betterSqliteError) {
+    try {
+      const { DatabaseSync } = require2("node:sqlite");
+      databaseDriver = "node:sqlite";
+      return new DatabaseSync(filename);
+    } catch (nodeSqliteError) {
+      throw new Error(
+        `Unable to initialize SQLite. Run on Node.js >=22.5.0, or install better-sqlite3 manually. better-sqlite3: ${describeLoadError(betterSqliteError)}; node:sqlite: ${describeLoadError(nodeSqliteError)}`
+      );
+    }
+  }
+}
+function applyPragma(database, pragma) {
+  const maybePragma = database.pragma;
+  if (typeof maybePragma === "function") {
+    maybePragma.call(database, pragma);
+  } else {
+    database.exec(`PRAGMA ${pragma}`);
+  }
+}
+function resolveSchemaPath() {
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join(moduleDir, "schema.sql"),
+    join(moduleDir, "database", "schema.sql"),
+    join(moduleDir, "..", "database", "schema.sql"),
+    join(process.cwd(), "src", "database", "schema.sql"),
+    join(process.cwd(), "dist", "database", "schema.sql")
+  ];
+  const schemaPath = candidates.find(existsSync);
+  if (!schemaPath) {
+    throw new Error(`Unable to locate database schema.sql. Searched: ${candidates.join(", ")}`);
+  }
+  return schemaPath;
+}
+function getDatabase() {
+  if (!db) {
+    const dbPath = getDatabasePath();
+    let dbDir;
+    let dbFile;
+    if (dbPath === ":memory:") {
+      dbDir = "";
+      dbFile = dbPath;
+    } else if (dbPath.endsWith(".db")) {
+      dbDir = dirname(dbPath);
+      dbFile = dbPath;
+    } else {
+      dbDir = dbPath;
+      dbFile = join(dbPath, "pi-missions.db");
+    }
+    if (dbDir && !existsSync(dbDir)) {
+      mkdirSync(dbDir, { recursive: true });
+    }
+    const candidateDb = openSqliteDatabase(dbFile);
+    try {
+      applyPragma(candidateDb, "journal_mode = WAL");
+      applyPragma(candidateDb, "foreign_keys = ON");
+      initializeSchema(candidateDb);
+      runMigrations(candidateDb);
+      db = candidateDb;
+    } catch (error) {
+      candidateDb.close();
+      throw error;
+    }
+  }
+  return db;
+}
+function getDatabasePath() {
+  return process.env.PI_MISSIONS_DB_PATH || join(homedir(), ".pi", "missions", "database");
+}
+function initializeSchema(db2) {
+  const schemaPath = resolveSchemaPath();
+  const schema = readFileSync(schemaPath, "utf-8");
+  try {
+    db2.exec(schema);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to initialize database schema from ${schemaPath}: ${message}`);
+  }
+}
+function ensureSchemaVersionTable(database) {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS schema_version (
+      id INTEGER PRIMARY KEY CHECK(id = 1),
+      version INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+    );
+  `);
+}
+function getSchemaVersion(database) {
+  ensureSchemaVersionTable(database);
+  const row = database.prepare("SELECT version FROM schema_version WHERE id = 1").get();
+  return row?.version ?? 0;
+}
+function setSchemaVersion(database, version) {
+  database.prepare(`
+    INSERT INTO schema_version (id, version, updated_at)
+    VALUES (1, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET
+      version = excluded.version,
+      updated_at = excluded.updated_at
+  `).run(version, Date.now());
+}
+function baselineExistingSchema(database) {
+  const row = database.prepare(`
+    SELECT 1 AS exists_flag
+    FROM sqlite_master
+    WHERE type = 'table' AND name = 'missions'
+    LIMIT 1
+  `).get();
+  if (row?.exists_flag === 1) {
+    setSchemaVersion(database, 1);
+  }
+}
+function runMigrations(database) {
+  ensureSchemaVersionTable(database);
+  const migrateBody = () => {
+    let version = getSchemaVersion(database);
+    if (version === 0) {
+      baselineExistingSchema(database);
+      version = getSchemaVersion(database);
+    }
+    if (version === 0) {
+      setSchemaVersion(database, CURRENT_SCHEMA_VERSION);
+    }
+  };
+  const maybeTransaction = database.transaction;
+  if (typeof maybeTransaction === "function") {
+    const migrate = maybeTransaction.call(database, migrateBody);
+    migrate();
+    return;
+  }
+  database.exec("BEGIN");
+  try {
+    migrateBody();
+    database.exec("COMMIT");
+  } catch (error) {
+    database.exec("ROLLBACK");
+    throw error;
+  }
+}
+var MISSION_UPDATABLE_COLUMNS = /* @__PURE__ */ new Set([
+  "title",
+  "goal",
+  "status",
+  "updated_at",
+  "completed_at",
+  "total_tokens",
+  "total_features",
+  "features_completed",
+  "features_failed",
+  "success_rate",
+  "tags",
+  "metadata"
+]);
+var MissionRepository = class {
+  db;
+  constructor(db2) {
+    this.db = db2;
+  }
+  create(mission) {
+    const now = Date.now();
+    const stmt = this.db.prepare(`
+      INSERT INTO missions (id, title, goal, status, created_at, updated_at, completed_at, 
+                           total_tokens, total_features, features_completed, features_failed, 
+                           success_rate, tags, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      mission.id,
+      mission.title,
+      mission.goal,
+      mission.status,
+      now,
+      now,
+      mission.completed_at,
+      mission.total_tokens,
+      mission.total_features,
+      mission.features_completed,
+      mission.features_failed,
+      mission.success_rate,
+      mission.tags,
+      mission.metadata
+    );
+    return this.findById(mission.id);
+  }
+  findById(id) {
+    return this.db.prepare("SELECT * FROM missions WHERE id = ?").get(id);
+  }
+  findAll(limit = 100, offset = 0) {
+    return this.db.prepare("SELECT * FROM missions ORDER BY updated_at DESC LIMIT ? OFFSET ?").all(limit, offset);
+  }
+  findByStatus(status) {
+    return this.db.prepare("SELECT * FROM missions WHERE status = ? ORDER BY updated_at DESC").all(status);
+  }
+  update(id, updates) {
+    const fields = Object.keys(updates).filter((k) => MISSION_UPDATABLE_COLUMNS.has(k));
+    if (fields.length === 0) return this.findById(id);
+    const setClause = fields.map((f) => `${f} = ?`).join(", ");
+    const values = fields.map((f) => updates[f]);
+    this.db.prepare(`UPDATE missions SET ${setClause}, updated_at = ? WHERE id = ?`).run(...values, Date.now(), id);
+    return this.findById(id);
+  }
+  delete(id) {
+    const result = this.db.prepare("DELETE FROM missions WHERE id = ?").run(id);
+    return result.changes > 0;
+  }
+  count() {
+    const row = this.db.prepare("SELECT COUNT(*) as count FROM missions").get();
+    return row?.count ?? 0;
+  }
+};
+var FEATURE_UPDATABLE_COLUMNS = /* @__PURE__ */ new Set([
+  "milestone_id",
+  "title",
+  "description",
+  "priority",
+  "status",
+  "depends_on",
+  "acceptance_criteria",
+  "sessions",
+  "tool_call_count",
+  "tokens_used",
+  "error_count",
+  "blockers",
+  "notes",
+  "started_at",
+  "completed_at",
+  "evidence"
+]);
+var FeatureRepository = class {
+  db;
+  constructor(db2) {
+    this.db = db2;
+  }
+  create(feature) {
+    const stmt = this.db.prepare(`
+      INSERT INTO features (id, milestone_id, mission_id, title, description, priority, status,
+                           depends_on, acceptance_criteria, sessions, tool_call_count, tokens_used,
+                           error_count, blockers, notes, created_at, started_at, completed_at, evidence)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      feature.id,
+      feature.milestone_id,
+      feature.mission_id,
+      feature.title,
+      feature.description,
+      feature.priority,
+      feature.status,
+      feature.depends_on,
+      feature.acceptance_criteria,
+      feature.sessions,
+      feature.tool_call_count,
+      feature.tokens_used,
+      feature.error_count,
+      feature.blockers,
+      feature.notes,
+      Date.now(),
+      feature.started_at,
+      feature.completed_at,
+      feature.evidence
+    );
+    return this.findById(feature.id, feature.mission_id);
+  }
+  findById(id, missionId) {
+    return this.db.prepare("SELECT * FROM features WHERE id = ? AND mission_id = ?").get(id, missionId);
+  }
+  findByMission(missionId) {
+    return this.db.prepare("SELECT * FROM features WHERE mission_id = ? ORDER BY created_at").all(missionId);
+  }
+  findByStatus(missionId, status) {
+    return this.db.prepare("SELECT * FROM features WHERE mission_id = ? AND status = ?").all(missionId, status);
+  }
+  update(id, missionId, updates) {
+    const fields = Object.keys(updates).filter((k) => FEATURE_UPDATABLE_COLUMNS.has(k));
+    if (fields.length === 0) return this.findById(id, missionId);
+    const setClause = fields.map((f) => `${f} = ?`).join(", ");
+    const values = fields.map((f) => updates[f]);
+    this.db.prepare(`UPDATE features SET ${setClause} WHERE id = ? AND mission_id = ?`).run(...values, id, missionId);
+    return this.findById(id, missionId);
+  }
+  delete(id, missionId) {
+    const result = this.db.prepare("DELETE FROM features WHERE id = ? AND mission_id = ?").run(id, missionId);
+    return result.changes > 0;
+  }
+};
+var HistoryRepository = class {
+  db;
+  constructor(db2) {
+    this.db = db2;
+  }
+  append(entry) {
+    const stmt = this.db.prepare(`
+      INSERT INTO history (mission_id, feature_id, event, note, details, timestamp, session_id)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    const result = stmt.run(
+      entry.mission_id,
+      entry.feature_id,
+      entry.event,
+      entry.note,
+      entry.details,
+      Date.now(),
+      entry.session_id
+    );
+    return this.db.prepare("SELECT * FROM history WHERE id = ?").get(result.lastInsertRowid);
+  }
+  findByMission(missionId, limit = 100) {
+    return this.db.prepare("SELECT * FROM history WHERE mission_id = ? ORDER BY timestamp DESC LIMIT ?").all(missionId, limit);
+  }
+  findByFeature(featureId, limit = 50) {
+    return this.db.prepare("SELECT * FROM history WHERE feature_id = ? ORDER BY timestamp DESC LIMIT ?").all(featureId, limit);
+  }
+  findByEvent(event, limit = 50) {
+    return this.db.prepare("SELECT * FROM history WHERE event = ? ORDER BY timestamp DESC LIMIT ?").all(event, limit);
+  }
+  search(query, limit = 50) {
+    return this.db.prepare(`
+      SELECT * FROM history 
+      WHERE note LIKE ? OR event LIKE ? 
+      ORDER BY timestamp DESC LIMIT ?
+    `).all(`%${query}%`, `%${query}%`, limit);
+  }
+};
+var LearningRepository = class {
+  db;
+  constructor(db2) {
+    this.db = db2;
+  }
+  create(learning) {
+    const stmt = this.db.prepare(`
+      INSERT INTO learnings (mission_id, feature_id, type, category, insight, confidence, applicable_to, context)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const result = stmt.run(
+      learning.mission_id,
+      learning.feature_id,
+      learning.type,
+      learning.category,
+      learning.insight,
+      learning.confidence,
+      learning.applicable_to,
+      learning.context
+    );
+    return this.db.prepare("SELECT * FROM learnings WHERE id = ?").get(result.lastInsertRowid);
+  }
+  findByType(type, limit = 50) {
+    return this.db.prepare("SELECT * FROM learnings WHERE type = ? ORDER BY confidence DESC LIMIT ?").all(type, limit);
+  }
+  findByCategory(category, limit = 50) {
+    return this.db.prepare("SELECT * FROM learnings WHERE category = ? ORDER BY confidence DESC LIMIT ?").all(category, limit);
+  }
+  findRelevant(tags, limit = 10) {
+    if (tags.length === 0) return [];
+    const placeholders = tags.map(() => "?").join(",");
+    return this.db.prepare(`
+      SELECT * FROM learnings 
+      WHERE json_valid(learnings.applicable_to)
+        AND EXISTS (
+        SELECT 1
+        FROM json_each(learnings.applicable_to)
+        WHERE json_each.value IN (${placeholders})
+      )
+      ORDER BY confidence DESC, used_count DESC
+      LIMIT ?
+    `).all(...tags, limit);
+  }
+  recordUsage(id, success) {
+    if (success) {
+      this.db.prepare("UPDATE learnings SET used_count = used_count + 1, success_count = success_count + 1 WHERE id = ?").run(id);
+    } else {
+      this.db.prepare("UPDATE learnings SET used_count = used_count + 1 WHERE id = ?").run(id);
+    }
+  }
+};
+var PatternRepository = class {
+  db;
+  constructor(db2) {
+    this.db = db2;
+  }
+  create(pattern) {
+    const stmt = this.db.prepare(`
+      INSERT INTO patterns (pattern_type, name, description, pattern_data, success_count, failure_count,
+                           success_rate, avg_duration_ms, avg_tokens, example_missions, tags)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const result = stmt.run(
+      pattern.pattern_type,
+      pattern.name,
+      pattern.description,
+      pattern.pattern_data,
+      pattern.success_count,
+      pattern.failure_count,
+      pattern.success_rate,
+      pattern.avg_duration_ms,
+      pattern.avg_tokens,
+      pattern.example_missions,
+      pattern.tags
+    );
+    return this.db.prepare("SELECT * FROM patterns WHERE id = ?").get(result.lastInsertRowid);
+  }
+  findByType(type, limit = 20) {
+    return this.db.prepare("SELECT * FROM patterns WHERE pattern_type = ? ORDER BY success_rate DESC LIMIT ?").all(type, limit);
+  }
+  findSuccessful(limit = 20) {
+    return this.db.prepare("SELECT * FROM patterns WHERE success_rate > 0.7 ORDER BY success_rate DESC LIMIT ?").all(limit);
+  }
+  recordOutcome(id, success) {
+    if (success) {
+      this.db.prepare(`
+        UPDATE patterns 
+        SET success_count = success_count + 1,
+            success_rate = CAST(success_count + 1 AS REAL) / (success_count + failure_count + 1),
+            updated_at = ?
+        WHERE id = ?
+      `).run(Date.now(), id);
+    } else {
+      this.db.prepare(`
+        UPDATE patterns 
+        SET failure_count = failure_count + 1,
+            success_rate = CAST(success_count AS REAL) / (success_count + failure_count + 1),
+            updated_at = ?
+        WHERE id = ?
+      `).run(Date.now(), id);
+    }
+  }
+};
+var TemplateRepository = class {
+  db;
+  constructor(db2) {
+    this.db = db2;
+  }
+  findById(id) {
+    return this.db.prepare("SELECT * FROM templates WHERE id = ?").get(id);
+  }
+  findAll(limit = 50) {
+    return this.db.prepare("SELECT * FROM templates ORDER BY rating DESC, usage_count DESC LIMIT ?").all(limit);
+  }
+  findByTags(tags) {
+    if (tags.length === 0) return [];
+    const placeholders = tags.map(() => "?").join(",");
+    return this.db.prepare(`
+      SELECT * FROM templates 
+      WHERE json_valid(templates.tags)
+        AND EXISTS (
+        SELECT 1
+        FROM json_each(templates.tags)
+        WHERE json_each.value IN (${placeholders})
+      )
+      ORDER BY rating DESC
+    `).all(...tags);
+  }
+  create(template) {
+    const now = Date.now();
+    const stmt = this.db.prepare(`
+      INSERT INTO templates (id, name, description, author, version, content, tags, difficulty,
+                            estimated_time_hours, estimated_tokens, usage_count, rating, rating_count,
+                            created_at, updated_at, is_builtin)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 0, 0, 0, ?, ?, ?)
+    `);
+    stmt.run(
+      template.id,
+      template.name,
+      template.description,
+      template.author,
+      template.version,
+      template.content,
+      template.tags,
+      template.difficulty,
+      template.estimated_time_hours,
+      template.estimated_tokens,
+      now,
+      now,
+      template.is_builtin
+    );
+    return this.findById(template.id);
+  }
+  incrementUsage(id) {
+    this.db.prepare("UPDATE templates SET usage_count = usage_count + 1, updated_at = ? WHERE id = ?").run(Date.now(), id);
+  }
+  rate(id, rating) {
+    this.db.prepare(`
+      UPDATE templates 
+      SET rating = (rating * rating_count + ?) / (rating_count + 1),
+          rating_count = rating_count + 1,
+          updated_at = ?
+      WHERE id = ?
+    `).run(rating, Date.now(), id);
+  }
+};
+var MetricRepository = class {
+  db;
+  constructor(db2) {
+    this.db = db2;
+  }
+  record(metric) {
+    const stmt = this.db.prepare(`
+      INSERT INTO metrics (metric_type, metric_name, value, unit, tags, recorded_at, period_start, period_end)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    const result = stmt.run(
+      metric.metric_type,
+      metric.metric_name,
+      metric.value,
+      metric.unit,
+      metric.tags,
+      Date.now(),
+      metric.period_start,
+      metric.period_end
+    );
+    return this.db.prepare("SELECT * FROM metrics WHERE id = ?").get(result.lastInsertRowid);
+  }
+  findByType(type, name, limit = 100) {
+    if (name) {
+      return this.db.prepare("SELECT * FROM metrics WHERE metric_type = ? AND metric_name = ? ORDER BY recorded_at DESC LIMIT ?").all(type, name, limit);
+    }
+    return this.db.prepare("SELECT * FROM metrics WHERE metric_type = ? ORDER BY recorded_at DESC LIMIT ?").all(type, limit);
+  }
+  getAggregated(type, name, periodMs) {
+    const since = Date.now() - periodMs;
+    const row = this.db.prepare(`
+      SELECT 
+        AVG(value) as avg,
+        MIN(value) as min,
+        MAX(value) as max,
+        COUNT(*) as count
+      FROM metrics 
+      WHERE metric_type = ? AND metric_name = ? AND recorded_at > ?
+    `).get(type, name, since);
+    return {
+      avg: row?.avg ?? 0,
+      min: row?.min ?? 0,
+      max: row?.max ?? 0,
+      count: row?.count ?? 0
+    };
+  }
+};
+var PredictionRepository = class {
+  db;
+  constructor(db2) {
+    this.db = db2;
+  }
+  create(prediction) {
+    const stmt = this.db.prepare(`
+      INSERT INTO predictions (mission_id, feature_id, prediction_type, predicted_value, actual_value, confidence, model_version)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+    const result = stmt.run(
+      prediction.mission_id,
+      prediction.feature_id,
+      prediction.prediction_type,
+      prediction.predicted_value,
+      prediction.actual_value ?? null,
+      prediction.confidence,
+      prediction.model_version
+    );
+    return this.db.prepare("SELECT * FROM predictions WHERE id = ?").get(result.lastInsertRowid);
+  }
+  validate(id, actualValue) {
+    const prediction = this.db.prepare("SELECT * FROM predictions WHERE id = ?").get(id);
+    if (!prediction) return;
+    const accuracy = 1 - Math.abs(prediction.predicted_value - actualValue) / Math.max(prediction.predicted_value, actualValue);
+    this.db.prepare(`
+      UPDATE predictions 
+      SET actual_value = ?, accuracy = ?, validated_at = ?
+      WHERE id = ?
+    `).run(actualValue, accuracy, Date.now(), id);
+  }
+  findByType(type, limit = 50) {
+    return this.db.prepare("SELECT * FROM predictions WHERE prediction_type = ? ORDER BY created_at DESC LIMIT ?").all(type, limit);
+  }
+  getAccuracy(type) {
+    const row = this.db.prepare(`
+      SELECT AVG(accuracy) as avg_accuracy 
+      FROM predictions 
+      WHERE prediction_type = ? AND accuracy IS NOT NULL
+    `).get(type);
+    return row?.avg_accuracy ?? 0;
+  }
+};
+function getRepositories() {
+  const db2 = getDatabase();
+  return {
+    missions: new MissionRepository(db2),
+    features: new FeatureRepository(db2),
+    history: new HistoryRepository(db2),
+    learnings: new LearningRepository(db2),
+    patterns: new PatternRepository(db2),
+    templates: new TemplateRepository(db2),
+    metrics: new MetricRepository(db2),
+    predictions: new PredictionRepository(db2)
+  };
+}
+
+// src/cli/index.ts
+import { pathToFileURL } from "url";
+var CLI = class {
+  commands = /* @__PURE__ */ new Map();
+  constructor() {
+    this.registerDefaultCommands();
+  }
+  registerCommand(cmd) {
+    this.commands.set(cmd.name, cmd);
+  }
+  async execute(args) {
+    const [cmd, ...rest] = args;
+    if (!cmd || cmd === "--help" || cmd === "-h") return this.showHelp();
+    const command = this.commands.get(cmd);
+    if (!command) return `Unknown command: ${cmd}. Use --help for available commands.`;
+    return command.execute(rest);
+  }
+  showHelp() {
+    const lines = ["Pi Missions CLI", "Usage: pi-missions <command> [options]", "", "Commands:"];
+    for (const [name, cmd] of this.commands) lines.push(`  ${name.padEnd(15)} ${cmd.description}`);
+    return lines.join("\n");
+  }
+  registerDefaultCommands() {
+    this.registerCommand({ name: "list", description: "List all missions", execute: async () => {
+      const repos = getRepositories();
+      const missions = repos.missions.findAll(50);
+      if (!missions.length) return "No missions found.";
+      return missions.map((m) => `${m.id} [${m.status}] ${m.title}`).join("\n");
+    } });
+    this.registerCommand({ name: "status", description: "Show mission status", execute: async (args) => {
+      const repos = getRepositories();
+      const id = args[0];
+      if (!id) return "Usage: pi-missions status <mission-id>";
+      const m = repos.missions.findById(id);
+      if (!m) return `Mission not found: ${id}`;
+      const features = repos.features.findByMission(id);
+      const done = features.filter((f) => f.status === "done").length;
+      return `${m.title}
+Status: ${m.status}
+Progress: ${done}/${features.length}
+Tokens: ${m.total_tokens}`;
+    } });
+    this.registerCommand({ name: "analytics", description: "Show analytics", execute: async () => {
+      const repos = getRepositories();
+      const missions = repos.missions.findAll(100);
+      const total = missions.length;
+      const completed = missions.filter((m) => m.status === "complete").length;
+      const active = missions.filter((m) => m.status === "active").length;
+      return `\u{1F4CA} Analytics
+Total: ${total}
+Active: ${active}
+Completed: ${completed}
+Success Rate: ${total > 0 ? Math.round(completed / total * 100) : 0}%`;
+    } });
+    this.registerCommand({ name: "templates", description: "List templates", execute: async () => {
+      const repos = getRepositories();
+      const templates = repos.templates.findAll();
+      return templates.map((t) => `${t.id.padEnd(15)} ${t.name} - ${t.description || ""}`).join("\n");
+    } });
+    this.registerCommand({ name: "history", description: "Show mission history", execute: async (args) => {
+      const repos = getRepositories();
+      const id = args[0];
+      if (!id) return "Usage: pi-missions history <mission-id>";
+      const history = repos.history.findByMission(id, 20);
+      if (!history.length) return "No history entries.";
+      return history.map((h) => `${new Date(h.timestamp).toISOString()} ${h.event} ${h.note || ""}`).join("\n");
+    } });
+    this.registerCommand({ name: "doctor", description: "Run diagnostics", execute: async () => {
+      const repos = getRepositories();
+      const missions = repos.missions.count();
+      const templates = repos.templates.findAll().length;
+      return `\u2705 Database: OK
+\u{1F4CA} Missions: ${missions}
+\u{1F4CB} Templates: ${templates}`;
+    } });
+  }
+};
+function createCLI() {
+  return new CLI();
+}
+function isDirectExecution() {
+  const entry = process.argv[1];
+  return Boolean(entry && import.meta.url === pathToFileURL(entry).href);
+}
+if (isDirectExecution()) {
+  createCLI().execute(process.argv.slice(2)).then((output) => {
+    if (output) console.log(output);
+  }).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  });
+}
+export {
+  CLI,
+  createCLI
+};
+//# sourceMappingURL=index.js.map