uda-cli 0.2.0

package/src/rag/store.js

@@ -0,0 +1,77 @@
+import * as lancedb from '@lancedb/lancedb';
+
+export class VectorStore {
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+    this.db = null;
+    this.table = null;
+    this.tableName = 'knowledge';
+  }
+
+  async init() {
+    this.db = await lancedb.connect(this.dbPath);
+
+    try {
+      this.table = await this.db.openTable(this.tableName);
+    } catch (err) {
+      // Table doesn't exist yet — will be created on first add
+      this.table = null;
+      if (err.message && !err.message.includes('does not exist') && !err.message.includes('not found') && !err.message.includes('was not found')) {
+        console.error(`Warning: Unexpected error opening table "${this.tableName}": ${err.message}`);
+      }
+    }
+  }
+
+  async add(documents) {
+    const rows = documents.map((doc) => ({
+      id: doc.id,
+      content: doc.content,
+      vector: doc.vector,
+      source: doc.metadata?.source || '',
+      engine: doc.metadata?.engine || '',
+      type: doc.metadata?.type || 'knowledge',
+      tags: JSON.stringify(doc.metadata?.tags || []),
+      date: doc.metadata?.date || new Date().toISOString().split('T')[0],
+    }));
+
+    if (!this.table) {
+      this.table = await this.db.createTable(this.tableName, rows);
+    } else {
+      await this.table.add(rows);
+    }
+  }
+
+  async search(queryVector, limit = 5) {
+    if (!this.table) return [];
+
+    const results = await this.table
+      .vectorSearch(queryVector)
+      .limit(limit)
+      .toArray();
+
+    return results.map((row) => ({
+      id: row.id,
+      content: row.content,
+      source: row.source,
+      engine: row.engine,
+      type: row.type,
+      tags: parseTags(row.tags),
+      score: row._distance,
+    }));
+  }
+
+  async count() {
+    if (!this.table) return 0;
+    return await this.table.countRows();
+  }
+}
+
+function parseTags(value) {
+  if (!value) return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}

package/src/workflows/parser.js

@@ -0,0 +1,49 @@
+// src/workflows/parser.js
+import YAML from 'yaml';
+
+export function parseWorkflow(yamlString) {
+  return YAML.parse(yamlString);
+}
+
+export function workflowToSkillMd(workflow) {
+  const lines = [
+    '---',
+    `description: ${workflow.description}`,
+    '---',
+    '',
+    `# ${workflow.name}`,
+    '',
+  ];
+
+  for (const step of workflow.steps || []) {
+    lines.push(`## ${step.name || step.id}`);
+
+    if (step.type === 'ask' && step.questions) {
+      lines.push('Ask the user:');
+      for (const q of step.questions) {
+        lines.push(`- "${q}"`);
+      }
+    }
+
+    if (step.type === 'auto' && step.actions) {
+      lines.push('Actions:');
+      for (const action of step.actions) {
+        if (typeof action === 'string') {
+          lines.push(`- ${action}`);
+        } else {
+          const key = Object.keys(action)[0];
+          lines.push(`- ${key}: ${JSON.stringify(action[key])}`);
+        }
+      }
+    }
+
+    if (step.type === 'agent') {
+      lines.push(`Delegate to agent: **${step.agent}**`);
+      if (step.output) lines.push(`Expected output: ${step.output}`);
+    }
+
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}