@axiom-lattice/pg-stores 1.0.3 → 1.0.5

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @axiom-lattice/pg-stores@1.0.3 build /home/runner/work/agentic/agentic/packages/pg-stores
+> @axiom-lattice/pg-stores@1.0.5 build /home/runner/work/agentic/agentic/packages/pg-stores
 > tsup src/index.ts --format cjs,esm --dts --sourcemap
 
 CLI Building entry: src/index.ts
@@ -8,13 +8,13 @@
 CLI Target: es2020
 CJS Build start
 ESM Build start
-CJS dist/index.js     34.68 KB
-CJS dist/index.js.map 61.72 KB
-CJS ⚡️ Build success in 123ms
-ESM dist/index.mjs     33.20 KB
-ESM dist/index.mjs.map 60.64 KB
-ESM ⚡️ Build success in 124ms
+CJS dist/index.js     44.48 KB
+CJS dist/index.js.map 80.78 KB
+CJS ⚡️ Build success in 211ms
+ESM dist/index.mjs     42.89 KB
+ESM dist/index.mjs.map 79.49 KB
+ESM ⚡️ Build success in 213ms
 DTS Build start
-DTS ⚡️ Build success in 5263ms
-DTS dist/index.d.ts  8.83 KB
-DTS dist/index.d.mts 8.83 KB
+DTS ⚡️ Build success in 7685ms
+DTS dist/index.d.ts  11.23 KB
+DTS dist/index.d.mts 11.23 KB

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @axiom-lattice/pg-stores
 
+## 1.0.5
+
+### Patch Changes
+
+- 773c03f: add skills
+- Updated dependencies [773c03f]
+  - @axiom-lattice/protocols@2.1.10
+  - @axiom-lattice/core@2.1.16
+
+## 1.0.4
+
+### Patch Changes
+
+- Updated dependencies [ef0fb84]
+  - @axiom-lattice/protocols@2.1.9
+  - @axiom-lattice/core@2.1.15
+
 ## 1.0.3
 
 ### Patch Changes

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { PoolConfig, PoolClient, Pool } from 'pg';
-import { ThreadStore, Thread, CreateThreadRequest, AssistantStore, Assistant, CreateAssistantRequest, ScheduleStorage, ScheduledTaskDefinition, ScheduledTaskStatus, ScheduleExecutionType } from '@axiom-lattice/protocols';
-export { Assistant, AssistantStore, CreateAssistantRequest, CreateThreadRequest, ScheduleExecutionType, ScheduleStorage, ScheduledTaskDefinition, ScheduledTaskStatus, Thread, ThreadStore } from '@axiom-lattice/protocols';
+import { ThreadStore, Thread, CreateThreadRequest, AssistantStore, Assistant, CreateAssistantRequest, ScheduleStorage, ScheduledTaskDefinition, ScheduledTaskStatus, ScheduleExecutionType, SkillStore, Skill, CreateSkillRequest } from '@axiom-lattice/protocols';
+export { Assistant, AssistantStore, CreateAssistantRequest, CreateSkillRequest, CreateThreadRequest, ScheduleExecutionType, ScheduleStorage, ScheduledTaskDefinition, ScheduledTaskStatus, Skill, SkillStore, Thread, ThreadStore } from '@axiom-lattice/protocols';
 
 /**
  * PostgreSQL implementation of ThreadStore
@@ -258,6 +258,93 @@ declare class PostgreSQLScheduleStorage implements ScheduleStorage {
     private mapRowToTask;
 }
 
+/**
+ * PostgreSQL implementation of SkillStore
+ */
+
+/**
+ * PostgreSQL SkillStore options
+ */
+interface PostgreSQLSkillStoreOptions {
+    /**
+     * PostgreSQL connection pool configuration
+     * Can be a connection string or PoolConfig object
+     */
+    poolConfig: string | PoolConfig;
+    /**
+     * Whether to run migrations automatically on initialization
+     * @default true
+     */
+    autoMigrate?: boolean;
+}
+/**
+ * PostgreSQL implementation of SkillStore
+ */
+declare class PostgreSQLSkillStore implements SkillStore {
+    private pool;
+    private migrationManager;
+    private initialized;
+    private ownsPool;
+    constructor(options: PostgreSQLSkillStoreOptions);
+    /**
+     * Dispose resources and close the connection pool
+     * Should be called when the store is no longer needed
+     */
+    dispose(): Promise<void>;
+    /**
+     * Initialize the store and run migrations
+     */
+    initialize(): Promise<void>;
+    /**
+     * Ensure store is initialized
+     */
+    private ensureInitialized;
+    /**
+     * Map database row to Skill object
+     */
+    private mapRowToSkill;
+    /**
+     * Get all skills
+     */
+    getAllSkills(): Promise<Skill[]>;
+    /**
+     * Get skill by ID
+     */
+    getSkillById(id: string): Promise<Skill | null>;
+    /**
+     * Create a new skill
+     */
+    createSkill(id: string, data: CreateSkillRequest): Promise<Skill>;
+    /**
+     * Update an existing skill
+     */
+    updateSkill(id: string, updates: Partial<CreateSkillRequest>): Promise<Skill | null>;
+    /**
+     * Delete a skill by ID
+     */
+    deleteSkill(id: string): Promise<boolean>;
+    /**
+     * Check if skill exists
+     */
+    hasSkill(id: string): Promise<boolean>;
+    /**
+     * Search skills by metadata
+     */
+    searchByMetadata(metadataKey: string, metadataValue: string): Promise<Skill[]>;
+    /**
+     * Filter skills by compatibility
+     */
+    filterByCompatibility(compatibility: string): Promise<Skill[]>;
+    /**
+     * Filter skills by license
+     */
+    filterByLicense(license: string): Promise<Skill[]>;
+    /**
+     * Get sub-skills of a parent skill
+     */
+    getSubSkills(parentSkillName: string): Promise<Skill[]>;
+}
+
 /**
  * Migration system for database schema management
  */
@@ -331,4 +418,13 @@ declare const createAssistantsTable: Migration;
  */
 declare const createScheduledTasksTable: Migration;
 
-export { type Migration, MigrationManager, PostgreSQLAssistantStore, type PostgreSQLAssistantStoreOptions, PostgreSQLScheduleStorage, type PostgreSQLScheduleStorageOptions, PostgreSQLThreadStore, type PostgreSQLThreadStoreOptions, createAssistantsTable, createScheduledTasksTable, createThreadsTable };
+/**
+ * Skill table migrations
+ */
+
+/**
+ * Initial migration: Create skills table
+ */
+declare const createSkillsTable: Migration;
+
+export { type Migration, MigrationManager, PostgreSQLAssistantStore, type PostgreSQLAssistantStoreOptions, PostgreSQLScheduleStorage, type PostgreSQLScheduleStorageOptions, PostgreSQLSkillStore, type PostgreSQLSkillStoreOptions, PostgreSQLThreadStore, type PostgreSQLThreadStoreOptions, createAssistantsTable, createScheduledTasksTable, createSkillsTable, createThreadsTable };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { PoolConfig, PoolClient, Pool } from 'pg';
-import { ThreadStore, Thread, CreateThreadRequest, AssistantStore, Assistant, CreateAssistantRequest, ScheduleStorage, ScheduledTaskDefinition, ScheduledTaskStatus, ScheduleExecutionType } from '@axiom-lattice/protocols';
-export { Assistant, AssistantStore, CreateAssistantRequest, CreateThreadRequest, ScheduleExecutionType, ScheduleStorage, ScheduledTaskDefinition, ScheduledTaskStatus, Thread, ThreadStore } from '@axiom-lattice/protocols';
+import { ThreadStore, Thread, CreateThreadRequest, AssistantStore, Assistant, CreateAssistantRequest, ScheduleStorage, ScheduledTaskDefinition, ScheduledTaskStatus, ScheduleExecutionType, SkillStore, Skill, CreateSkillRequest } from '@axiom-lattice/protocols';
+export { Assistant, AssistantStore, CreateAssistantRequest, CreateSkillRequest, CreateThreadRequest, ScheduleExecutionType, ScheduleStorage, ScheduledTaskDefinition, ScheduledTaskStatus, Skill, SkillStore, Thread, ThreadStore } from '@axiom-lattice/protocols';
 
 /**
  * PostgreSQL implementation of ThreadStore
@@ -258,6 +258,93 @@ declare class PostgreSQLScheduleStorage implements ScheduleStorage {
     private mapRowToTask;
 }
 
+/**
+ * PostgreSQL implementation of SkillStore
+ */
+
+/**
+ * PostgreSQL SkillStore options
+ */
+interface PostgreSQLSkillStoreOptions {
+    /**
+     * PostgreSQL connection pool configuration
+     * Can be a connection string or PoolConfig object
+     */
+    poolConfig: string | PoolConfig;
+    /**
+     * Whether to run migrations automatically on initialization
+     * @default true
+     */
+    autoMigrate?: boolean;
+}
+/**
+ * PostgreSQL implementation of SkillStore
+ */
+declare class PostgreSQLSkillStore implements SkillStore {
+    private pool;
+    private migrationManager;
+    private initialized;
+    private ownsPool;
+    constructor(options: PostgreSQLSkillStoreOptions);
+    /**
+     * Dispose resources and close the connection pool
+     * Should be called when the store is no longer needed
+     */
+    dispose(): Promise<void>;
+    /**
+     * Initialize the store and run migrations
+     */
+    initialize(): Promise<void>;
+    /**
+     * Ensure store is initialized
+     */
+    private ensureInitialized;
+    /**
+     * Map database row to Skill object
+     */
+    private mapRowToSkill;
+    /**
+     * Get all skills
+     */
+    getAllSkills(): Promise<Skill[]>;
+    /**
+     * Get skill by ID
+     */
+    getSkillById(id: string): Promise<Skill | null>;
+    /**
+     * Create a new skill
+     */
+    createSkill(id: string, data: CreateSkillRequest): Promise<Skill>;
+    /**
+     * Update an existing skill
+     */
+    updateSkill(id: string, updates: Partial<CreateSkillRequest>): Promise<Skill | null>;
+    /**
+     * Delete a skill by ID
+     */
+    deleteSkill(id: string): Promise<boolean>;
+    /**
+     * Check if skill exists
+     */
+    hasSkill(id: string): Promise<boolean>;
+    /**
+     * Search skills by metadata
+     */
+    searchByMetadata(metadataKey: string, metadataValue: string): Promise<Skill[]>;
+    /**
+     * Filter skills by compatibility
+     */
+    filterByCompatibility(compatibility: string): Promise<Skill[]>;
+    /**
+     * Filter skills by license
+     */
+    filterByLicense(license: string): Promise<Skill[]>;
+    /**
+     * Get sub-skills of a parent skill
+     */
+    getSubSkills(parentSkillName: string): Promise<Skill[]>;
+}
+
 /**
  * Migration system for database schema management
  */
@@ -331,4 +418,13 @@ declare const createAssistantsTable: Migration;
  */
 declare const createScheduledTasksTable: Migration;
 
-export { type Migration, MigrationManager, PostgreSQLAssistantStore, type PostgreSQLAssistantStoreOptions, PostgreSQLScheduleStorage, type PostgreSQLScheduleStorageOptions, PostgreSQLThreadStore, type PostgreSQLThreadStoreOptions, createAssistantsTable, createScheduledTasksTable, createThreadsTable };
+/**
+ * Skill table migrations
+ */
+
+/**
+ * Initial migration: Create skills table
+ */
+declare const createSkillsTable: Migration;
+
+export { type Migration, MigrationManager, PostgreSQLAssistantStore, type PostgreSQLAssistantStoreOptions, PostgreSQLScheduleStorage, type PostgreSQLScheduleStorageOptions, PostgreSQLSkillStore, type PostgreSQLSkillStoreOptions, PostgreSQLThreadStore, type PostgreSQLThreadStoreOptions, createAssistantsTable, createScheduledTasksTable, createSkillsTable, createThreadsTable };

package/dist/index.js

@@ -23,9 +23,11 @@ __export(index_exports, {
   MigrationManager: () => MigrationManager,
   PostgreSQLAssistantStore: () => PostgreSQLAssistantStore,
   PostgreSQLScheduleStorage: () => PostgreSQLScheduleStorage,
+  PostgreSQLSkillStore: () => PostgreSQLSkillStore,
   PostgreSQLThreadStore: () => PostgreSQLThreadStore,
   createAssistantsTable: () => createAssistantsTable,
   createScheduledTasksTable: () => createScheduledTasksTable,
+  createSkillsTable: () => createSkillsTable,
   createThreadsTable: () => createThreadsTable
 });
 module.exports = __toCommonJS(index_exports);
@@ -1146,14 +1148,352 @@ var PostgreSQLScheduleStorage = class {
     };
   }
 };
+
+// src/stores/PostgreSQLSkillStore.ts
+var import_pg4 = require("pg");
+
+// src/migrations/skill_migrations.ts
+var createSkillsTable = {
+  version: 1,
+  name: "create_skills_table",
+  up: async (client) => {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS lattice_skills (
+        id VARCHAR(255) PRIMARY KEY,
+        name VARCHAR(255) NOT NULL,
+        description TEXT NOT NULL,
+        license VARCHAR(255),
+        compatibility VARCHAR(255),
+        metadata JSONB DEFAULT '{}',
+        content TEXT,
+        sub_skills JSONB DEFAULT '[]',
+        created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_skills_name 
+      ON lattice_skills(name)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_skills_license 
+      ON lattice_skills(license)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_skills_compatibility 
+      ON lattice_skills(compatibility)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_skills_created_at 
+      ON lattice_skills(created_at DESC)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_lattice_skills_metadata 
+      ON lattice_skills USING GIN (metadata)
+    `);
+  },
+  down: async (client) => {
+    await client.query("DROP INDEX IF EXISTS idx_lattice_skills_metadata");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_skills_created_at");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_skills_compatibility");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_skills_license");
+    await client.query("DROP INDEX IF EXISTS idx_lattice_skills_name");
+    await client.query("DROP TABLE IF EXISTS lattice_skills");
+  }
+};
+
+// src/stores/PostgreSQLSkillStore.ts
+var PostgreSQLSkillStore = class {
+  constructor(options) {
+    this.initialized = false;
+    this.ownsPool = true;
+    if (typeof options.poolConfig === "string") {
+      this.pool = new import_pg4.Pool({ connectionString: options.poolConfig });
+    } else {
+      this.pool = new import_pg4.Pool(options.poolConfig);
+    }
+    this.migrationManager = new MigrationManager(this.pool);
+    this.migrationManager.register(createSkillsTable);
+    if (options.autoMigrate !== false) {
+      this.initialize().catch((error) => {
+        console.error("Failed to initialize PostgreSQLSkillStore:", error);
+        throw error;
+      });
+    }
+  }
+  /**
+   * Dispose resources and close the connection pool
+   * Should be called when the store is no longer needed
+   */
+  async dispose() {
+    if (this.ownsPool && this.pool) {
+      await this.pool.end();
+    }
+  }
+  /**
+   * Initialize the store and run migrations
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    await this.migrationManager.migrate();
+    this.initialized = true;
+  }
+  /**
+   * Ensure store is initialized
+   */
+  async ensureInitialized() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+  }
+  /**
+   * Map database row to Skill object
+   */
+  mapRowToSkill(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      description: row.description,
+      license: row.license || void 0,
+      compatibility: row.compatibility || void 0,
+      metadata: row.metadata || {},
+      content: row.content || void 0,
+      subSkills: Array.isArray(row.sub_skills) && row.sub_skills.length > 0 ? row.sub_skills : void 0,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  /**
+   * Get all skills
+   */
+  async getAllSkills() {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      SELECT id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
+      FROM lattice_skills
+      ORDER BY created_at DESC
+    `
+    );
+    return result.rows.map(this.mapRowToSkill);
+  }
+  /**
+   * Get skill by ID
+   */
+  async getSkillById(id) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      SELECT id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
+      FROM lattice_skills
+      WHERE id = $1
+    `,
+      [id]
+    );
+    if (result.rows.length === 0) {
+      return null;
+    }
+    return this.mapRowToSkill(result.rows[0]);
+  }
+  /**
+   * Create a new skill
+   */
+  async createSkill(id, data) {
+    await this.ensureInitialized();
+    const now = /* @__PURE__ */ new Date();
+    const metadata = data.metadata || {};
+    await this.pool.query(
+      `
+      INSERT INTO lattice_skills (id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at)
+      VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+      ON CONFLICT (id) DO UPDATE SET
+        name = EXCLUDED.name,
+        description = EXCLUDED.description,
+        license = EXCLUDED.license,
+        compatibility = EXCLUDED.compatibility,
+        metadata = EXCLUDED.metadata,
+        content = EXCLUDED.content,
+        sub_skills = EXCLUDED.sub_skills,
+        updated_at = EXCLUDED.updated_at
+    `,
+      [
+        id,
+        data.name,
+        data.description,
+        data.license || null,
+        data.compatibility || null,
+        JSON.stringify(metadata),
+        data.content || null,
+        JSON.stringify(data.subSkills || []),
+        now,
+        now
+      ]
+    );
+    return this.getSkillById(id);
+  }
+  /**
+   * Update an existing skill
+   */
+  async updateSkill(id, updates) {
+    await this.ensureInitialized();
+    const updateFields = [];
+    const values = [];
+    let paramIndex = 1;
+    if (updates.name !== void 0) {
+      updateFields.push(`name = $${paramIndex++}`);
+      values.push(updates.name);
+    }
+    if (updates.description !== void 0) {
+      updateFields.push(`description = $${paramIndex++}`);
+      values.push(updates.description);
+    }
+    if (updates.license !== void 0) {
+      updateFields.push(`license = $${paramIndex++}`);
+      values.push(updates.license || null);
+    }
+    if (updates.compatibility !== void 0) {
+      updateFields.push(`compatibility = $${paramIndex++}`);
+      values.push(updates.compatibility || null);
+    }
+    if (updates.metadata !== void 0) {
+      updateFields.push(`metadata = $${paramIndex++}`);
+      values.push(JSON.stringify(updates.metadata || {}));
+    }
+    if (updates.content !== void 0) {
+      updateFields.push(`content = $${paramIndex++}`);
+      values.push(updates.content || null);
+    }
+    if (updates.subSkills !== void 0) {
+      updateFields.push(`sub_skills = $${paramIndex++}`);
+      values.push(JSON.stringify(updates.subSkills || []));
+    }
+    if (updateFields.length === 0) {
+      return this.getSkillById(id);
+    }
+    updateFields.push(`updated_at = $${paramIndex++}`);
+    values.push(/* @__PURE__ */ new Date());
+    values.push(id);
+    await this.pool.query(
+      `
+      UPDATE lattice_skills
+      SET ${updateFields.join(", ")}
+      WHERE id = $${paramIndex}
+    `,
+      values
+    );
+    return this.getSkillById(id);
+  }
+  /**
+   * Delete a skill by ID
+   */
+  async deleteSkill(id) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      DELETE FROM lattice_skills
+      WHERE id = $1
+    `,
+      [id]
+    );
+    return result.rowCount !== null && result.rowCount > 0;
+  }
+  /**
+   * Check if skill exists
+   */
+  async hasSkill(id) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      SELECT COUNT(*) as count
+      FROM lattice_skills
+      WHERE id = $1
+    `,
+      [id]
+    );
+    return parseInt(result.rows[0].count, 10) > 0;
+  }
+  /**
+   * Search skills by metadata
+   */
+  async searchByMetadata(metadataKey, metadataValue) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      SELECT id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
+      FROM lattice_skills
+      WHERE metadata->>$1 = $2
+      ORDER BY created_at DESC
+    `,
+      [metadataKey, metadataValue]
+    );
+    return result.rows.map(this.mapRowToSkill);
+  }
+  /**
+   * Filter skills by compatibility
+   */
+  async filterByCompatibility(compatibility) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      SELECT id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
+      FROM lattice_skills
+      WHERE compatibility = $1
+      ORDER BY created_at DESC
+    `,
+      [compatibility]
+    );
+    return result.rows.map(this.mapRowToSkill);
+  }
+  /**
+   * Filter skills by license
+   */
+  async filterByLicense(license) {
+    await this.ensureInitialized();
+    const result = await this.pool.query(
+      `
+      SELECT id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
+      FROM lattice_skills
+      WHERE license = $1
+      ORDER BY created_at DESC
+    `,
+      [license]
+    );
+    return result.rows.map(this.mapRowToSkill);
+  }
+  /**
+   * Get sub-skills of a parent skill
+   */
+  async getSubSkills(parentSkillName) {
+    await this.ensureInitialized();
+    const parentSkill = await this.getSkillById(parentSkillName);
+    if (!parentSkill || !parentSkill.subSkills || parentSkill.subSkills.length === 0) {
+      return [];
+    }
+    const placeholders = parentSkill.subSkills.map((_, index) => `$${index + 1}`).join(", ");
+    const result = await this.pool.query(
+      `
+      SELECT id, name, description, license, compatibility, metadata, content, sub_skills, created_at, updated_at
+      FROM lattice_skills
+      WHERE name IN (${placeholders})
+      ORDER BY created_at DESC
+    `,
+      parentSkill.subSkills
+    );
+    return result.rows.map(this.mapRowToSkill);
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   MigrationManager,
   PostgreSQLAssistantStore,
   PostgreSQLScheduleStorage,
+  PostgreSQLSkillStore,
   PostgreSQLThreadStore,
   createAssistantsTable,
   createScheduledTasksTable,
+  createSkillsTable,
   createThreadsTable
 });
 //# sourceMappingURL=index.js.map