skill-tree 0.2.0 → 0.3.0

package/dist/chunk-MR4TVINH.mjs

@@ -0,0 +1,1234 @@
+// src/storage/sqlite.ts
+import * as path from "path";
+import * as fs from "fs";
+
+// src/storage/base.ts
+var _BaseStorageAdapter = class _BaseStorageAdapter {
+  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.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 queryTerms = this.tokenize(query);
+    if (queryTerms.length === 0) return [];
+    const N = skills.length;
+    const k1 = 1.5;
+    const b = 0.75;
+    const docs = skills.map((skill) => ({
+      skill,
+      terms: this.tokenize(
+        [skill.name, skill.description, ...skill.tags].join(" ")
+      )
+    }));
+    const avgDl = docs.reduce((sum, d) => sum + d.terms.length, 0) / (N || 1);
+    const df = /* @__PURE__ */ new Map();
+    for (const doc of docs) {
+      const unique = new Set(doc.terms);
+      for (const t of unique) {
+        df.set(t, (df.get(t) ?? 0) + 1);
+      }
+    }
+    const scored = docs.map((doc) => {
+      let score = 0;
+      const tf = /* @__PURE__ */ new Map();
+      for (const t of doc.terms) {
+        tf.set(t, (tf.get(t) ?? 0) + 1);
+      }
+      for (const qt of queryTerms) {
+        const termDf = df.get(qt) ?? 0;
+        if (termDf === 0) continue;
+        const idf = Math.log((N - termDf + 0.5) / (termDf + 0.5) + 1);
+        const termTf = tf.get(qt) ?? 0;
+        const tfNorm = termTf * (k1 + 1) / (termTf + k1 * (1 - b + b * doc.terms.length / avgDl));
+        score += idf * tfNorm;
+      }
+      return { skill: doc.skill, score };
+    });
+    return scored.filter((s) => s.score > 0).sort((a, b2) => b2.score - a.score).map((s) => s.skill);
+  }
+  tokenize(text) {
+    return text.toLowerCase().split(/\W+/).filter((t) => t.length > 1 && !_BaseStorageAdapter.STOP_WORDS.has(t)).map((t) => _BaseStorageAdapter.stem(t));
+  }
+  static stem(word) {
+    if (word.length <= 3) return word;
+    let w = word;
+    w = w.replace(/ies$/, "y");
+    w = w.replace(/(ation|tion)$/, "t");
+    w = w.replace(/sion$/, "s");
+    w = w.replace(/(ing|ment|ness|able|ible|ous|ive|ful|less|ize|ise|ance|ence)$/, "");
+    w = w.replace(/([^aeiou])ed$/, "$1");
+    w = w.replace(/es$/, "");
+    w = w.replace(/([^s])s$/, "$1");
+    w = w.replace(/(.)\1$/, "$1");
+    if (w.length <= 1) return word;
+    return w;
+  }
+};
+_BaseStorageAdapter.STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "shall",
+  "can",
+  "to",
+  "of",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "as",
+  "into",
+  "through",
+  "and",
+  "but",
+  "or",
+  "not",
+  "so",
+  "yet",
+  "if",
+  "when",
+  "that",
+  "this",
+  "it",
+  "its",
+  "also",
+  "which",
+  "what",
+  "how",
+  "why",
+  "where"
+]);
+var BaseStorageAdapter = _BaseStorageAdapter;
+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({
+      instructions: skill.instructions
+    });
+    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 = 3;
+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 = await this.openDatabase(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;
+  }
+  /**
+   * Open the underlying SQLite database. Defaults to better-sqlite3, loaded
+   * lazily so the native addon is only required when this adapter is actually
+   * used. Subclasses (e.g. {@link NodeSqliteStorageAdapter}) override this to
+   * supply a different, cross-runtime driver.
+   */
+  async openDatabase(dbPath) {
+    const { default: Database } = await import("./lib-B245IUXF.mjs");
+    return new Database(dbPath);
+  }
+  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,
+        instructions TEXT NOT NULL DEFAULT '',
+        related 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,
+        source TEXT,
+        taxonomy TEXT,
+        external_source TEXT
+      )
+    `);
+    try {
+      db.exec("ALTER TABLE skills DROP COLUMN metrics");
+    } catch {
+      const cols = db.prepare("PRAGMA table_info(skills)").all();
+      if (cols.some((c) => c.name === "metrics")) {
+        this.rebuildSkillsTableWithoutMetrics(db, cols);
+      }
+    }
+    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,
+          instructions,
+          tags
+        )
+      `);
+    }
+    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 {
+        }
+      }
+      if (currentVersion < 3) {
+        try {
+          db.exec("ALTER TABLE skills ADD COLUMN instructions TEXT NOT NULL DEFAULT ''");
+        } catch {
+        }
+        try {
+          db.exec("ALTER TABLE skills ADD COLUMN related TEXT");
+        } catch {
+        }
+        try {
+          db.exec(`
+            UPDATE skills SET instructions =
+              COALESCE(problem, '') || CHAR(10) || CHAR(10) ||
+              COALESCE(solution, '') || CHAR(10) || CHAR(10) ||
+              COALESCE(verification, '')
+            WHERE instructions = ''
+          `);
+        } catch {
+        }
+        if (this.config.enableFTS) {
+          try {
+            db.exec("DROP TABLE IF EXISTS skills_fts");
+            db.exec(`
+              CREATE VIRTUAL TABLE skills_fts USING fts5(
+                skill_id, name, description, instructions, tags
+              )
+            `);
+            const rows = db.prepare("SELECT id, name, description, instructions, tags FROM skills").all();
+            const insertFts = db.prepare("INSERT INTO skills_fts (skill_id, name, description, instructions, tags) VALUES (?, ?, ?, ?, ?)");
+            for (const row2 of rows) {
+              const tags = (() => {
+                try {
+                  return JSON.parse(row2.tags).join(" ");
+                } catch {
+                  return row2.tags;
+                }
+              })();
+              insertFts.run(row2.id, row2.name, row2.description, row2.instructions, tags);
+            }
+          } catch {
+          }
+        }
+      }
+      db.prepare("UPDATE schema_version SET version = ?").run(SCHEMA_VERSION);
+    }
+  }
+  /**
+   * Rebuild the `skills` table without the legacy `metrics` column.
+   *
+   * Used as the fallback path on SQLite < 3.35 where ALTER TABLE DROP
+   * COLUMN isn't supported. Uses the standard "table dance" pattern:
+   * CREATE NEW → INSERT FROM OLD → DROP OLD → RENAME, inside a single
+   * transaction so a partial state can't outlive a crash.
+   *
+   * The `existingCols` arg is the full PRAGMA table_info output for the
+   * legacy table — we use it to figure out which columns to copy. Some
+   * legacy installs may have a subset of the current schema's columns
+   * (e.g., taxonomy/external_source were added in v2, related in v3),
+   * so we only copy columns that exist on both sides.
+   */
+  rebuildSkillsTableWithoutMetrics(db, existingCols) {
+    const NEW_SCHEMA_COLUMNS = [
+      "id",
+      "version",
+      "name",
+      "description",
+      "instructions",
+      "related",
+      "author",
+      "tags",
+      "created_at",
+      "updated_at",
+      "status",
+      "parent_version",
+      "derived_from",
+      "source",
+      "taxonomy",
+      "external_source"
+    ];
+    const sourceNames = new Set(existingCols.map((c) => c.name));
+    const copyable = NEW_SCHEMA_COLUMNS.filter((c) => sourceNames.has(c));
+    const copyList = copyable.join(", ");
+    db.exec("BEGIN");
+    try {
+      db.exec(`
+        CREATE TABLE skills_new (
+          id TEXT PRIMARY KEY,
+          version TEXT NOT NULL,
+          name TEXT NOT NULL,
+          description TEXT,
+          instructions TEXT NOT NULL DEFAULT '',
+          related 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,
+          source TEXT,
+          taxonomy TEXT,
+          external_source TEXT
+        )
+      `);
+      db.exec(
+        `INSERT INTO skills_new (${copyList}) SELECT ${copyList} FROM skills`
+      );
+      db.exec("DROP TABLE skills");
+      db.exec("ALTER TABLE skills_new RENAME TO skills");
+      db.exec("COMMIT");
+    } catch (err) {
+      db.exec("ROLLBACK");
+      throw err;
+    }
+  }
+  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, instructions, related, author, tags,
+        created_at, updated_at, status, parent_version, derived_from,
+        source, taxonomy, external_source
+      ) VALUES (
+        ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+      )
+    `);
+    stmt.run(
+      skill.id,
+      skill.version,
+      skill.name,
+      skill.description,
+      skill.instructions,
+      skill.related ? JSON.stringify(skill.related) : 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,
+      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 tags = skill.tags.join(" ");
+    db.prepare(`
+      INSERT INTO skills_fts (skill_id, name, description, instructions, tags)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(skill.id, skill.name, skill.description, skill.instructions, tags);
+  }
+  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?.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,
+      instructions: row.instructions,
+      related: row.related ? JSON.parse(row.related) : 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,
+      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
+    };
+  }
+  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
+    };
+  }
+  hashSkill(skill) {
+    const content = JSON.stringify({
+      instructions: skill.instructions
+    });
+    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
+};