skill-tree 0.1.2 → 0.1.4

package/dist/chunk-PDPN7FW7.mjs

@@ -0,0 +1,1045 @@
+// src/storage/sqlite.ts
+import Database from "better-sqlite3";
+import * as path from "path";
+import * as fs from "fs";
+
+// src/storage/base.ts
+var BaseStorageAdapter = class {
+  constructor() {
+    this.initialized = false;
+  }
+  /**
+   * Ensure storage is initialized before operations
+   */
+  ensureInitialized() {
+    if (!this.initialized) {
+      throw new Error("Storage not initialized. Call initialize() first.");
+    }
+  }
+  /**
+   * Apply filters to a list of skills
+   */
+  applyFilter(skills, filter) {
+    if (!filter) return skills;
+    return skills.filter((skill) => {
+      if (filter.status && filter.status.length > 0) {
+        if (!filter.status.includes(skill.status)) return false;
+      }
+      if (filter.tags && filter.tags.length > 0) {
+        const hasTag = filter.tags.some((tag) => skill.tags.includes(tag));
+        if (!hasTag) return false;
+      }
+      if (filter.author && skill.author !== filter.author) {
+        return false;
+      }
+      if (filter.minSuccessRate !== void 0 && skill.metrics.successRate < filter.minSuccessRate) {
+        return false;
+      }
+      if (filter.createdAfter && skill.createdAt < filter.createdAfter) {
+        return false;
+      }
+      if (filter.createdBefore && skill.createdAt > filter.createdBefore) {
+        return false;
+      }
+      if (!this.applyNamespaceFilter(skill, filter)) {
+        return false;
+      }
+      return true;
+    });
+  }
+  /**
+   * Apply namespace-related filters to a skill
+   */
+  applyNamespaceFilter(skill, filter) {
+    const namespace = skill.namespace;
+    if (filter.scope) {
+      const scopes = Array.isArray(filter.scope) ? filter.scope : [filter.scope];
+      const skillScope = namespace?.scope || "personal";
+      if (!scopes.includes(skillScope)) return false;
+    }
+    if (filter.owner) {
+      const skillOwner = namespace?.owner;
+      if (skillOwner !== filter.owner) return false;
+    }
+    if (filter.team) {
+      const skillTeam = namespace?.team;
+      if (skillTeam !== filter.team) return false;
+    }
+    if (filter.visibility) {
+      const visibilities = Array.isArray(filter.visibility) ? filter.visibility : [filter.visibility];
+      const skillVisibility = namespace?.visibility || "private";
+      if (!visibilities.includes(skillVisibility)) return false;
+    }
+    if (filter.accessibleBy) {
+      if (!this.canAgentAccessSkill(skill, filter.accessibleBy, filter.accessibleByTeam)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Check if an agent can access a skill based on namespace rules
+   */
+  canAgentAccessSkill(skill, agentId, agentTeam) {
+    const namespace = skill.namespace;
+    if (!namespace) return true;
+    if (namespace.owner === agentId) return true;
+    switch (namespace.visibility) {
+      case "public":
+        return true;
+      case "team-only":
+        return agentTeam !== void 0 && agentTeam === namespace.team;
+      case "private":
+        return namespace.owner === agentId;
+      default:
+        return false;
+    }
+  }
+  /**
+   * Simple text search across skill fields
+   */
+  textSearch(skills, query) {
+    const lowerQuery = query.toLowerCase();
+    const terms = lowerQuery.split(/\s+/).filter((t) => t.length > 0);
+    return skills.filter((skill) => {
+      const searchText = [
+        skill.name,
+        skill.description,
+        skill.problem,
+        skill.solution,
+        ...skill.tags,
+        skill.triggerConditions.map((t) => t.value).join(" ")
+      ].join(" ").toLowerCase();
+      return terms.every((term) => searchText.includes(term));
+    });
+  }
+};
+var MemoryStorageAdapter = class extends BaseStorageAdapter {
+  constructor() {
+    super(...arguments);
+    this.skills = /* @__PURE__ */ new Map();
+    // skillId -> version -> skill
+    this.lineages = /* @__PURE__ */ new Map();
+  }
+  async initialize() {
+    this.initialized = true;
+  }
+  async saveSkill(skill) {
+    this.ensureInitialized();
+    if (!this.skills.has(skill.id)) {
+      this.skills.set(skill.id, /* @__PURE__ */ new Map());
+    }
+    const versionMap = this.skills.get(skill.id);
+    versionMap.set(skill.version, { ...skill });
+    this.updateLineage(skill);
+  }
+  async getSkill(id, version) {
+    this.ensureInitialized();
+    const versionMap = this.skills.get(id);
+    if (!versionMap) return null;
+    if (version) {
+      return versionMap.get(version) || null;
+    }
+    const versions = Array.from(versionMap.keys()).sort(this.compareVersions);
+    const latestVersion = versions[versions.length - 1];
+    return latestVersion ? versionMap.get(latestVersion) || null : null;
+  }
+  async listSkills(filter) {
+    this.ensureInitialized();
+    const skills = [];
+    for (const versionMap of this.skills.values()) {
+      const versions = Array.from(versionMap.keys()).sort(this.compareVersions);
+      const latestVersion = versions[versions.length - 1];
+      if (latestVersion) {
+        const skill = versionMap.get(latestVersion);
+        if (skill) skills.push(skill);
+      }
+    }
+    return this.applyFilter(skills, filter);
+  }
+  async deleteSkill(id, version) {
+    this.ensureInitialized();
+    if (version) {
+      const versionMap = this.skills.get(id);
+      if (!versionMap) return false;
+      return versionMap.delete(version);
+    }
+    const existed = this.skills.has(id);
+    this.skills.delete(id);
+    this.lineages.delete(id);
+    return existed;
+  }
+  async getVersionHistory(skillId) {
+    this.ensureInitialized();
+    const versionMap = this.skills.get(skillId);
+    if (!versionMap) return [];
+    const versions = [];
+    for (const [version, skill] of versionMap) {
+      versions.push({
+        skillId,
+        version,
+        skill,
+        changelog: "",
+        // Not tracked in memory
+        createdAt: skill.createdAt,
+        contentHash: this.hashSkill(skill)
+      });
+    }
+    return versions.sort((a, b) => this.compareVersions(a.version, b.version));
+  }
+  async getLineage(skillId) {
+    this.ensureInitialized();
+    return this.lineages.get(skillId) || null;
+  }
+  async searchSkills(query) {
+    this.ensureInitialized();
+    const allSkills = await this.listSkills();
+    return this.textSearch(allSkills, query);
+  }
+  updateLineage(skill) {
+    if (!this.lineages.has(skill.id)) {
+      this.lineages.set(skill.id, {
+        rootId: skill.id,
+        versions: [],
+        forks: []
+      });
+    }
+    const lineage = this.lineages.get(skill.id);
+    const existingIndex = lineage.versions.findIndex((v) => v.version === skill.version);
+    const versionEntry = {
+      skillId: skill.id,
+      version: skill.version,
+      skill,
+      changelog: "",
+      createdAt: skill.createdAt,
+      contentHash: this.hashSkill(skill)
+    };
+    if (existingIndex >= 0) {
+      lineage.versions[existingIndex] = versionEntry;
+    } else {
+      lineage.versions.push(versionEntry);
+      lineage.versions.sort((a, b) => this.compareVersions(a.version, b.version));
+    }
+  }
+  compareVersions(a, b) {
+    const partsA = a.split(".").map(Number);
+    const partsB = b.split(".").map(Number);
+    for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+      const numA = partsA[i] || 0;
+      const numB = partsB[i] || 0;
+      if (numA !== numB) return numA - numB;
+    }
+    return 0;
+  }
+  hashSkill(skill) {
+    const content = JSON.stringify({
+      problem: skill.problem,
+      solution: skill.solution,
+      triggerConditions: skill.triggerConditions
+    });
+    let hash = 0;
+    for (let i = 0; i < content.length; i++) {
+      const char = content.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(16);
+  }
+  /**
+   * Clear all stored skills (for testing)
+   */
+  clear() {
+    this.skills.clear();
+    this.lineages.clear();
+  }
+  // ==========================================================================
+  // Fork Tracking
+  // ==========================================================================
+  async recordFork(sourceSkillId, fork) {
+    this.ensureInitialized();
+    const lineage = this.lineages.get(sourceSkillId);
+    if (lineage) {
+      const exists = lineage.forks.some(
+        (f) => f.forkedSkillId === fork.forkedSkillId
+      );
+      if (!exists) {
+        lineage.forks.push(fork);
+      }
+    }
+  }
+};
+
+// src/storage/sqlite.ts
+var SCHEMA_VERSION = 2;
+var SQLiteStorageAdapter = class extends BaseStorageAdapter {
+  constructor(config) {
+    super();
+    this.db = null;
+    this.config = {
+      walMode: true,
+      enableFTS: true,
+      ...config
+    };
+  }
+  async initialize() {
+    const dir = path.dirname(this.config.dbPath);
+    if (dir && !fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    this.db = new Database(this.config.dbPath);
+    if (this.config.walMode) {
+      this.db.pragma("journal_mode = WAL");
+    }
+    this.db.pragma("foreign_keys = ON");
+    this.createSchema();
+    this.runMigrations();
+    this.initialized = true;
+  }
+  createSchema() {
+    const db = this.getDb();
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS schema_version (
+        version INTEGER PRIMARY KEY
+      )
+    `);
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS skills (
+        id TEXT PRIMARY KEY,
+        version TEXT NOT NULL,
+        name TEXT NOT NULL,
+        description TEXT NOT NULL,
+        problem TEXT NOT NULL,
+        trigger_conditions TEXT NOT NULL,
+        solution TEXT NOT NULL,
+        verification TEXT NOT NULL,
+        examples TEXT NOT NULL,
+        notes TEXT,
+        author TEXT NOT NULL,
+        tags TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        status TEXT NOT NULL,
+        parent_version TEXT,
+        derived_from TEXT,
+        metrics TEXT NOT NULL,
+        source TEXT,
+        taxonomy TEXT,
+        external_source TEXT
+      )
+    `);
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS skill_versions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        skill_id TEXT NOT NULL,
+        version TEXT NOT NULL,
+        skill_data TEXT NOT NULL,
+        changelog TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        content_hash TEXT NOT NULL,
+        UNIQUE(skill_id, version)
+      )
+    `);
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS skill_lineage (
+        skill_id TEXT PRIMARY KEY,
+        root_id TEXT NOT NULL
+      )
+    `);
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS skill_forks (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        root_skill_id TEXT NOT NULL,
+        forked_skill_id TEXT NOT NULL,
+        from_version TEXT NOT NULL,
+        reason TEXT NOT NULL,
+        forked_at TEXT NOT NULL,
+        FOREIGN KEY (root_skill_id) REFERENCES skill_lineage(skill_id)
+      )
+    `);
+    db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_skills_status ON skills(status);
+      CREATE INDEX IF NOT EXISTS idx_skills_author ON skills(author);
+      CREATE INDEX IF NOT EXISTS idx_skills_updated ON skills(updated_at);
+      CREATE INDEX IF NOT EXISTS idx_versions_skill ON skill_versions(skill_id);
+    `);
+    if (this.config.enableFTS) {
+      db.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS skills_fts USING fts5(
+          skill_id,
+          name,
+          description,
+          problem,
+          solution,
+          tags,
+          trigger_values
+        )
+      `);
+    }
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS taxonomy_nodes (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        description TEXT,
+        parent_id TEXT REFERENCES taxonomy_nodes(id),
+        path TEXT NOT NULL,
+        skill_count INTEGER DEFAULT 0,
+        created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS skill_taxonomy_placements (
+        skill_id TEXT NOT NULL,
+        node_id TEXT NOT NULL,
+        is_primary INTEGER DEFAULT 0,
+        confidence REAL,
+        reasoning TEXT,
+        created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY (skill_id, node_id)
+      )
+    `);
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS skill_relationships (
+        source_skill_id TEXT NOT NULL,
+        target_skill_id TEXT NOT NULL,
+        type TEXT NOT NULL,
+        confidence REAL NOT NULL,
+        reasoning TEXT,
+        created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY (source_skill_id, target_skill_id, type)
+      )
+    `);
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS skill_sources (
+        id TEXT PRIMARY KEY,
+        type TEXT NOT NULL,
+        url TEXT,
+        last_scraped TEXT,
+        etag TEXT,
+        skill_count INTEGER DEFAULT 0
+      )
+    `);
+    db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_taxonomy_parent ON taxonomy_nodes(parent_id);
+      CREATE INDEX IF NOT EXISTS idx_taxonomy_path ON taxonomy_nodes(path);
+      CREATE INDEX IF NOT EXISTS idx_placements_skill ON skill_taxonomy_placements(skill_id);
+      CREATE INDEX IF NOT EXISTS idx_placements_node ON skill_taxonomy_placements(node_id);
+      CREATE INDEX IF NOT EXISTS idx_relationships_source ON skill_relationships(source_skill_id);
+      CREATE INDEX IF NOT EXISTS idx_relationships_target ON skill_relationships(target_skill_id);
+    `);
+    const version = db.prepare("SELECT version FROM schema_version").get();
+    if (!version) {
+      db.prepare("INSERT INTO schema_version (version) VALUES (?)").run(SCHEMA_VERSION);
+    }
+  }
+  runMigrations() {
+    const db = this.getDb();
+    const row = db.prepare("SELECT version FROM schema_version").get();
+    const currentVersion = row?.version || 0;
+    if (currentVersion < SCHEMA_VERSION) {
+      if (currentVersion < 2) {
+        try {
+          db.exec("ALTER TABLE skills ADD COLUMN taxonomy TEXT");
+        } catch {
+        }
+        try {
+          db.exec("ALTER TABLE skills ADD COLUMN external_source TEXT");
+        } catch {
+        }
+      }
+      db.prepare("UPDATE schema_version SET version = ?").run(SCHEMA_VERSION);
+    }
+  }
+  getDb() {
+    if (!this.db) {
+      throw new Error("Database not initialized. Call initialize() first.");
+    }
+    return this.db;
+  }
+  async saveSkill(skill) {
+    this.ensureInitialized();
+    const db = this.getDb();
+    const stmt = db.prepare(`
+      INSERT OR REPLACE INTO skills (
+        id, version, name, description, problem, trigger_conditions, solution,
+        verification, examples, notes, author, tags, created_at, updated_at,
+        status, parent_version, derived_from, metrics, source, taxonomy, external_source
+      ) VALUES (
+        ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+      )
+    `);
+    stmt.run(
+      skill.id,
+      skill.version,
+      skill.name,
+      skill.description,
+      skill.problem,
+      JSON.stringify(skill.triggerConditions),
+      skill.solution,
+      skill.verification,
+      JSON.stringify(skill.examples),
+      skill.notes || null,
+      skill.author,
+      JSON.stringify(skill.tags),
+      skill.createdAt.toISOString(),
+      skill.updatedAt.toISOString(),
+      skill.status,
+      skill.parentVersion || null,
+      skill.derivedFrom ? JSON.stringify(skill.derivedFrom) : null,
+      JSON.stringify(skill.metrics),
+      skill.source ? JSON.stringify(skill.source) : null,
+      skill.taxonomy ? JSON.stringify(skill.taxonomy) : null,
+      skill.externalSource ? JSON.stringify({
+        ...skill.externalSource,
+        scrapedAt: skill.externalSource.scrapedAt.toISOString()
+      }) : null
+    );
+    if (skill.relationships && skill.relationships.length > 0) {
+      await this.saveSkillRelationships(skill.id, skill.relationships);
+    }
+    if (this.config.enableFTS) {
+      this.updateFTSIndex(skill);
+    }
+    await this.saveVersionSnapshot(skill);
+    this.updateLineage(skill);
+  }
+  updateFTSIndex(skill) {
+    const db = this.getDb();
+    db.prepare("DELETE FROM skills_fts WHERE skill_id = ?").run(skill.id);
+    const triggerValues = skill.triggerConditions.map((t) => t.value).join(" ");
+    const tags = skill.tags.join(" ");
+    db.prepare(`
+      INSERT INTO skills_fts (skill_id, name, description, problem, solution, tags, trigger_values)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(skill.id, skill.name, skill.description, skill.problem, skill.solution, tags, triggerValues);
+  }
+  async saveVersionSnapshot(skill) {
+    const db = this.getDb();
+    const existing = db.prepare(
+      "SELECT id FROM skill_versions WHERE skill_id = ? AND version = ?"
+    ).get(skill.id, skill.version);
+    if (existing) {
+      db.prepare(`
+        UPDATE skill_versions
+        SET skill_data = ?, content_hash = ?
+        WHERE skill_id = ? AND version = ?
+      `).run(
+        JSON.stringify(this.serializeSkill(skill)),
+        this.hashSkill(skill),
+        skill.id,
+        skill.version
+      );
+    } else {
+      db.prepare(`
+        INSERT INTO skill_versions (skill_id, version, skill_data, changelog, created_at, content_hash)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `).run(
+        skill.id,
+        skill.version,
+        JSON.stringify(this.serializeSkill(skill)),
+        "",
+        // Changelog can be added via separate method
+        skill.createdAt.toISOString(),
+        this.hashSkill(skill)
+      );
+    }
+  }
+  updateLineage(skill) {
+    const db = this.getDb();
+    const existing = db.prepare(
+      "SELECT skill_id FROM skill_lineage WHERE skill_id = ?"
+    ).get(skill.id);
+    if (!existing) {
+      db.prepare(
+        "INSERT INTO skill_lineage (skill_id, root_id) VALUES (?, ?)"
+      ).run(skill.id, skill.id);
+    }
+  }
+  async getSkill(id, version) {
+    this.ensureInitialized();
+    const db = this.getDb();
+    if (version) {
+      const row2 = db.prepare(
+        "SELECT skill_data FROM skill_versions WHERE skill_id = ? AND version = ?"
+      ).get(id, version);
+      if (!row2) return null;
+      return this.deserializeSkill(JSON.parse(row2.skill_data));
+    }
+    const row = db.prepare("SELECT * FROM skills WHERE id = ?").get(id);
+    if (!row) return null;
+    return this.rowToSkill(row);
+  }
+  async listSkills(filter) {
+    this.ensureInitialized();
+    const db = this.getDb();
+    let sql = "SELECT * FROM skills WHERE 1=1";
+    const params = [];
+    if (filter?.status && filter.status.length > 0) {
+      sql += ` AND status IN (${filter.status.map(() => "?").join(",")})`;
+      params.push(...filter.status);
+    }
+    if (filter?.author) {
+      sql += " AND author = ?";
+      params.push(filter.author);
+    }
+    if (filter?.minSuccessRate !== void 0) {
+      sql += " AND json_extract(metrics, '$.successRate') >= ?";
+      params.push(filter.minSuccessRate);
+    }
+    if (filter?.createdAfter) {
+      sql += " AND created_at >= ?";
+      params.push(filter.createdAfter.toISOString());
+    }
+    if (filter?.createdBefore) {
+      sql += " AND created_at <= ?";
+      params.push(filter.createdBefore.toISOString());
+    }
+    sql += " ORDER BY updated_at DESC";
+    const rows = db.prepare(sql).all(...params);
+    let skills = rows.map((row) => this.rowToSkill(row));
+    if (filter?.tags && filter.tags.length > 0) {
+      skills = skills.filter(
+        (skill) => filter.tags.some((tag) => skill.tags.includes(tag))
+      );
+    }
+    return skills;
+  }
+  async deleteSkill(id, version) {
+    this.ensureInitialized();
+    const db = this.getDb();
+    if (version) {
+      const result = db.prepare(
+        "DELETE FROM skill_versions WHERE skill_id = ? AND version = ?"
+      ).run(id, version);
+      return result.changes > 0;
+    }
+    const transaction = db.transaction(() => {
+      db.prepare("DELETE FROM skill_versions WHERE skill_id = ?").run(id);
+      db.prepare("DELETE FROM skill_forks WHERE root_skill_id = ? OR forked_skill_id = ?").run(id, id);
+      db.prepare("DELETE FROM skill_lineage WHERE skill_id = ?").run(id);
+      if (this.config.enableFTS) {
+        db.prepare("DELETE FROM skills_fts WHERE skill_id = ?").run(id);
+      }
+      db.prepare("DELETE FROM skill_taxonomy_placements WHERE skill_id = ?").run(id);
+      db.prepare("DELETE FROM skill_relationships WHERE source_skill_id = ? OR target_skill_id = ?").run(id, id);
+      const result = db.prepare("DELETE FROM skills WHERE id = ?").run(id);
+      return result.changes > 0;
+    });
+    return transaction();
+  }
+  async getVersionHistory(skillId) {
+    this.ensureInitialized();
+    const db = this.getDb();
+    const rows = db.prepare(`
+      SELECT skill_id, version, skill_data, changelog, created_at, content_hash
+      FROM skill_versions
+      WHERE skill_id = ?
+      ORDER BY created_at ASC
+    `).all(skillId);
+    return rows.map((row) => ({
+      skillId: row.skill_id,
+      version: row.version,
+      skill: this.deserializeSkill(JSON.parse(row.skill_data)),
+      changelog: row.changelog,
+      createdAt: new Date(row.created_at),
+      contentHash: row.content_hash
+    }));
+  }
+  async getLineage(skillId) {
+    this.ensureInitialized();
+    const db = this.getDb();
+    const lineageRow = db.prepare(
+      "SELECT * FROM skill_lineage WHERE skill_id = ?"
+    ).get(skillId);
+    if (!lineageRow) return null;
+    const versions = await this.getVersionHistory(skillId);
+    const forkRows = db.prepare(`
+      SELECT forked_skill_id, from_version, reason, forked_at
+      FROM skill_forks
+      WHERE root_skill_id = ?
+    `).all(skillId);
+    const forks = forkRows.map((row) => ({
+      forkedSkillId: row.forked_skill_id,
+      fromVersion: row.from_version,
+      reason: row.reason,
+      forkedAt: new Date(row.forked_at)
+    }));
+    return {
+      rootId: lineageRow.root_id,
+      versions,
+      forks
+    };
+  }
+  async searchSkills(query) {
+    this.ensureInitialized();
+    const db = this.getDb();
+    if (this.config.enableFTS) {
+      const rows = db.prepare(`
+        SELECT s.* FROM skills s
+        JOIN skills_fts fts ON s.id = fts.skill_id
+        WHERE skills_fts MATCH ?
+        ORDER BY rank
+      `).all(query);
+      return rows.map((row) => this.rowToSkill(row));
+    }
+    const allSkills = await this.listSkills();
+    return this.textSearch(allSkills, query);
+  }
+  /**
+   * Add a fork record
+   */
+  async addFork(rootSkillId, forkedSkillId, fromVersion, reason) {
+    this.ensureInitialized();
+    const db = this.getDb();
+    db.prepare(`
+      INSERT INTO skill_forks (root_skill_id, forked_skill_id, from_version, reason, forked_at)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(rootSkillId, forkedSkillId, fromVersion, reason, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  /**
+   * Update changelog for a version
+   */
+  async updateChangelog(skillId, version, changelog) {
+    this.ensureInitialized();
+    const db = this.getDb();
+    db.prepare(`
+      UPDATE skill_versions SET changelog = ? WHERE skill_id = ? AND version = ?
+    `).run(changelog, skillId, version);
+  }
+  /**
+   * Get skills by tag
+   */
+  async getSkillsByTag(tag) {
+    return this.listSkills({ tags: [tag] });
+  }
+  /**
+   * Get all tags with counts
+   */
+  async getTagCounts() {
+    this.ensureInitialized();
+    const db = this.getDb();
+    const rows = db.prepare("SELECT tags FROM skills").all();
+    const counts = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const tags = JSON.parse(row.tags);
+      for (const tag of tags) {
+        counts.set(tag, (counts.get(tag) || 0) + 1);
+      }
+    }
+    return counts;
+  }
+  /**
+   * Get skill count by status
+   */
+  async getStatusCounts() {
+    this.ensureInitialized();
+    const db = this.getDb();
+    const rows = db.prepare(`
+      SELECT status, COUNT(*) as count FROM skills GROUP BY status
+    `).all();
+    const counts = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      counts.set(row.status, row.count);
+    }
+    return counts;
+  }
+  /**
+   * Close the database connection
+   */
+  close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+      this.initialized = false;
+    }
+  }
+  /**
+   * Export all skills for backup
+   */
+  async exportAll() {
+    return this.listSkills();
+  }
+  /**
+   * Import skills from backup
+   */
+  async importSkills(skills) {
+    let imported = 0;
+    let failed = 0;
+    for (const skill of skills) {
+      try {
+        await this.saveSkill(skill);
+        imported++;
+      } catch {
+        failed++;
+      }
+    }
+    return { imported, failed };
+  }
+  // =========================================================================
+  // TAXONOMY METHODS
+  // =========================================================================
+  /**
+   * Get or create a taxonomy node
+   */
+  async ensureTaxonomyNode(path2) {
+    this.ensureInitialized();
+    const db = this.getDb();
+    const pathStr = path2.join("/");
+    const existing = db.prepare("SELECT id FROM taxonomy_nodes WHERE path = ?").get(pathStr);
+    if (existing) return existing.id;
+    const id = `node-${pathStr.replace(/\//g, "-").toLowerCase()}`;
+    const name = path2[path2.length - 1] || "Root";
+    const parentPath = path2.slice(0, -1);
+    let parentId = null;
+    if (parentPath.length > 0) {
+      parentId = await this.ensureTaxonomyNode(parentPath);
+    }
+    db.prepare(`
+      INSERT INTO taxonomy_nodes (id, name, parent_id, path, created_at)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(id, name, parentId, pathStr, (/* @__PURE__ */ new Date()).toISOString());
+    return id;
+  }
+  /**
+   * Place a skill in the taxonomy
+   */
+  async placeInTaxonomy(skillId, taxonomy) {
+    this.ensureInitialized();
+    const db = this.getDb();
+    const primaryNodeId = await this.ensureTaxonomyNode(taxonomy.primaryPath);
+    db.prepare(`
+      INSERT OR REPLACE INTO skill_taxonomy_placements
+      (skill_id, node_id, is_primary, confidence, created_at)
+      VALUES (?, ?, 1, ?, ?)
+    `).run(skillId, primaryNodeId, taxonomy.confidence || null, (/* @__PURE__ */ new Date()).toISOString());
+    db.prepare("UPDATE taxonomy_nodes SET skill_count = skill_count + 1 WHERE id = ?").run(primaryNodeId);
+    if (taxonomy.secondaryPaths) {
+      for (const secondaryPath of taxonomy.secondaryPaths) {
+        const secondaryNodeId = await this.ensureTaxonomyNode(secondaryPath);
+        db.prepare(`
+          INSERT OR IGNORE INTO skill_taxonomy_placements
+          (skill_id, node_id, is_primary, created_at)
+          VALUES (?, ?, 0, ?)
+        `).run(skillId, secondaryNodeId, (/* @__PURE__ */ new Date()).toISOString());
+      }
+    }
+  }
+  /**
+   * Get taxonomy tree
+   */
+  async getTaxonomyTree(rootPath) {
+    this.ensureInitialized();
+    const db = this.getDb();
+    let sql = "SELECT * FROM taxonomy_nodes";
+    const params = [];
+    if (rootPath && rootPath.length > 0) {
+      const pathPrefix = rootPath.join("/");
+      sql += " WHERE path LIKE ? OR path = ?";
+      params.push(`${pathPrefix}/%`, pathPrefix);
+    }
+    sql += " ORDER BY path";
+    const rows = db.prepare(sql).all(...params);
+    const nodeMap = /* @__PURE__ */ new Map();
+    const roots = [];
+    for (const row of rows) {
+      const node = {
+        id: row.id,
+        name: row.name,
+        path: row.path.split("/"),
+        skillCount: row.skill_count,
+        children: []
+      };
+      nodeMap.set(row.id, node);
+      if (row.parent_id && nodeMap.has(row.parent_id)) {
+        nodeMap.get(row.parent_id).children.push(node);
+      } else {
+        roots.push(node);
+      }
+    }
+    return roots;
+  }
+  /**
+   * Get skills in a taxonomy node
+   */
+  async getSkillsInTaxonomyNode(nodeId) {
+    this.ensureInitialized();
+    const db = this.getDb();
+    const rows = db.prepare(`
+      SELECT s.* FROM skills s
+      JOIN skill_taxonomy_placements p ON s.id = p.skill_id
+      WHERE p.node_id = ?
+    `).all(nodeId);
+    return rows.map((row) => this.rowToSkill(row));
+  }
+  // =========================================================================
+  // RELATIONSHIP METHODS
+  // =========================================================================
+  /**
+   * Save skill relationships
+   */
+  async saveSkillRelationships(skillId, relationships) {
+    const db = this.getDb();
+    db.prepare("DELETE FROM skill_relationships WHERE source_skill_id = ?").run(skillId);
+    const stmt = db.prepare(`
+      INSERT OR REPLACE INTO skill_relationships
+      (source_skill_id, target_skill_id, type, confidence, reasoning, created_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+    for (const rel of relationships) {
+      stmt.run(
+        skillId,
+        rel.targetSkillId,
+        rel.type,
+        rel.confidence,
+        rel.reasoning || null,
+        (/* @__PURE__ */ new Date()).toISOString()
+      );
+    }
+  }
+  /**
+   * Add a relationship between skills
+   */
+  async addRelationship(sourceSkillId, targetSkillId, type, confidence, reasoning) {
+    this.ensureInitialized();
+    const db = this.getDb();
+    db.prepare(`
+      INSERT OR REPLACE INTO skill_relationships
+      (source_skill_id, target_skill_id, type, confidence, reasoning, created_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(sourceSkillId, targetSkillId, type, confidence, reasoning || null, (/* @__PURE__ */ new Date()).toISOString());
+  }
+  /**
+   * Get relationships for a skill
+   */
+  async getRelationships(skillId) {
+    this.ensureInitialized();
+    const db = this.getDb();
+    const rows = db.prepare(`
+      SELECT target_skill_id, type, confidence, reasoning
+      FROM skill_relationships
+      WHERE source_skill_id = ?
+    `).all(skillId);
+    return rows.map((row) => ({
+      targetSkillId: row.target_skill_id,
+      type: row.type,
+      confidence: row.confidence,
+      reasoning: row.reasoning || void 0
+    }));
+  }
+  /**
+   * Get skills that depend on a given skill
+   */
+  async getDependentSkills(skillId) {
+    this.ensureInitialized();
+    const db = this.getDb();
+    const rows = db.prepare(`
+      SELECT s.* FROM skills s
+      JOIN skill_relationships r ON s.id = r.source_skill_id
+      WHERE r.target_skill_id = ? AND r.type = 'depends_on'
+    `).all(skillId);
+    return rows.map((row) => this.rowToSkill(row));
+  }
+  /**
+   * Get related skills (any relationship type)
+   */
+  async getRelatedSkills(skillId) {
+    this.ensureInitialized();
+    const db = this.getDb();
+    const rows = db.prepare(`
+      SELECT s.*, r.type, r.confidence, r.reasoning
+      FROM skills s
+      JOIN skill_relationships r ON s.id = r.target_skill_id
+      WHERE r.source_skill_id = ?
+    `).all(skillId);
+    return rows.map((row) => ({
+      skill: this.rowToSkill(row),
+      relationship: {
+        targetSkillId: row.id,
+        type: row.type,
+        confidence: row.confidence,
+        reasoning: row.reasoning || void 0
+      }
+    }));
+  }
+  // =========================================================================
+  // HELPER METHODS
+  // =========================================================================
+  rowToSkill(row) {
+    const externalSource = row.external_source ? JSON.parse(row.external_source) : void 0;
+    return {
+      id: row.id,
+      version: row.version,
+      name: row.name,
+      description: row.description,
+      problem: row.problem,
+      triggerConditions: JSON.parse(row.trigger_conditions),
+      solution: row.solution,
+      verification: row.verification,
+      examples: JSON.parse(row.examples),
+      notes: row.notes || void 0,
+      author: row.author,
+      tags: JSON.parse(row.tags),
+      createdAt: new Date(row.created_at),
+      updatedAt: new Date(row.updated_at),
+      status: row.status,
+      parentVersion: row.parent_version || void 0,
+      derivedFrom: row.derived_from ? JSON.parse(row.derived_from) : void 0,
+      metrics: JSON.parse(row.metrics),
+      source: row.source ? JSON.parse(row.source) : void 0,
+      taxonomy: row.taxonomy ? JSON.parse(row.taxonomy) : void 0,
+      externalSource: externalSource ? {
+        ...externalSource,
+        scrapedAt: new Date(externalSource.scrapedAt)
+      } : void 0
+    };
+  }
+  serializeSkill(skill) {
+    return {
+      ...skill,
+      createdAt: skill.createdAt.toISOString(),
+      updatedAt: skill.updatedAt.toISOString(),
+      source: skill.source ? {
+        ...skill.source,
+        importedAt: skill.source.importedAt.toISOString()
+      } : void 0,
+      metrics: {
+        ...skill.metrics,
+        lastUsed: skill.metrics.lastUsed?.toISOString()
+      }
+    };
+  }
+  deserializeSkill(data) {
+    return {
+      ...data,
+      createdAt: new Date(data.createdAt),
+      updatedAt: new Date(data.updatedAt),
+      source: data.source ? {
+        ...data.source,
+        importedAt: new Date(data.source.importedAt)
+      } : void 0,
+      metrics: {
+        ...data.metrics,
+        lastUsed: data.metrics.lastUsed ? new Date(data.metrics.lastUsed) : void 0
+      }
+    };
+  }
+  hashSkill(skill) {
+    const content = JSON.stringify({
+      problem: skill.problem,
+      solution: skill.solution,
+      triggerConditions: skill.triggerConditions
+    });
+    let hash = 0;
+    for (let i = 0; i < content.length; i++) {
+      const char = content.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(16);
+  }
+};
+
+export {
+  BaseStorageAdapter,
+  MemoryStorageAdapter,
+  SQLiteStorageAdapter
+};