skill-tree 0.1.4 → 0.1.6

package/dist/chunk-PDPN7FW7.mjs

@@ -1,1045 +0,0 @@
-// 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
-};