uda-cli 0.2.0

package/src/commands/init.js

@@ -0,0 +1,62 @@
+import { initProject } from '../core/init.js';
+import { handleScan } from './scan.js';
+import { handleSync } from './sync.js';
+import { validateEngine } from '../core/validators.js';
+
+export async function handleInit(options) {
+  const root = process.cwd();
+
+  // Validate engine option if provided
+  if (options.engine) {
+    const v = validateEngine(options.engine);
+    if (!v.valid) {
+      console.error(`✘ ${v.error}`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  console.log('UDA v0.2.0\n');
+
+  // Step 1: Create directory structure
+  console.log('Creating project structure...');
+  try {
+    await initProject(root);
+  } catch (err) {
+    console.error(`✘ Failed to create project structure: ${err.message}`);
+    process.exitCode = 1;
+    return;
+  }
+  console.log('✔ .uda/ directory created\n');
+
+  // Step 2: Engine detection
+  const engine = options.engine || await detectEngine(root);
+  if (engine) {
+    console.log(`✔ Engine detected: ${engine}`);
+    console.log(`  Run \`uda plugin add <repo>\` to install ${engine} plugin\n`);
+  }
+
+  // Step 3: Initial scan
+  console.log('Scanning knowledge base...');
+  await handleScan();
+
+  // Step 4: Generate AI tool files
+  console.log('\nGenerating AI tool files...');
+  await handleSync();
+
+  console.log('\n✔ UDA is ready!');
+  console.log('  uda search "your query"');
+  console.log('  uda learn <file.md>');
+  console.log('  uda plugin add <git-repo>');
+}
+
+async function detectEngine(root) {
+  const { existsSync } = await import('fs');
+  const { join } = await import('path');
+
+  if (existsSync(join(root, 'ProjectSettings', 'ProjectVersion.txt'))) return 'unity';
+  if (existsSync(join(root, 'project.godot'))) return 'godot';
+  if (existsSync(join(root, 'Config', 'DefaultEngine.ini'))) return 'unreal';
+
+  return null;
+}

package/src/commands/learn.js

@@ -0,0 +1,82 @@
+// src/commands/learn.js
+import { resolve, extname } from 'path';
+import { stat, readFile } from 'fs/promises';
+import { RagManager } from '../rag/manager.js';
+import { udaPaths } from '../core/constants.js';
+import { validateLearnType } from '../core/validators.js';
+
+export async function handleLearn(source, options) {
+  // Guard against missing source argument
+  if (!source || (typeof source === 'string' && source.trim() === '')) {
+    console.error('✘ Source file path is required.');
+    process.exitCode = 1;
+    return;
+  }
+
+  // Validate learn type if provided
+  if (options.type) {
+    const tv = validateLearnType(options.type);
+    if (!tv.valid) {
+      console.error(`✘ ${tv.error}`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  const paths = udaPaths(process.cwd());
+
+  let rag;
+  try {
+    rag = new RagManager(paths.rag.lancedb);
+    await rag.init();
+  } catch (err) {
+    console.error(`✘ Failed to initialize RAG engine: ${err.message}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const sourcePath = resolve(source);
+
+  let info;
+  try {
+    info = await stat(sourcePath);
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      console.error(`✘ File not found: ${sourcePath}`);
+    } else {
+      console.error(`✘ Cannot access file "${sourcePath}": ${err.message}`);
+    }
+    process.exitCode = 1;
+    return;
+  }
+
+  if (!info.isFile()) {
+    console.error(`✘ Source must be a file path, not a directory: ${sourcePath}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  // Warn if file is not markdown
+  const ext = extname(sourcePath).toLowerCase();
+  if (ext && ext !== '.md' && ext !== '.markdown') {
+    console.log(`⚠ Warning: "${source}" is not a markdown file. Results may vary.`);
+  }
+
+  // Check for empty files
+  if (info.size === 0) {
+    console.error(`✘ File is empty: ${sourcePath}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  try {
+    const count = await rag.learnFile(sourcePath, {
+      type: options.type || 'knowledge',
+      tags: options.tags ? options.tags.split(',') : [],
+    });
+    console.log(`✔ Learned ${count} chunks from ${source}`);
+  } catch (err) {
+    console.error(`✘ Failed to learn from "${source}": ${err.message}`);
+    process.exitCode = 1;
+  }
+}

package/src/commands/logs.js

@@ -0,0 +1,70 @@
+import { readFile, readdir } from 'fs/promises';
+import { join } from 'path';
+import { udaPaths } from '../core/constants.js';
+
+export async function handleLogs(options) {
+  const root = process.cwd();
+  const paths = udaPaths(root);
+  const logsDir = paths.logs;
+
+  // Find log files
+  let logFiles;
+  try {
+    const files = await readdir(logsDir);
+    logFiles = files.filter(f => f.endsWith('.jsonl'));
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      console.log('No log files found. Is a log bridge plugin installed?');
+      return;
+    }
+    throw err;
+  }
+
+  if (logFiles.length === 0) {
+    console.log('No log files found. Is a log bridge plugin installed?');
+    return;
+  }
+
+  // Read and parse all log entries
+  let entries = [];
+  for (const file of logFiles) {
+    const content = await readFile(join(logsDir, file), 'utf8');
+    const lines = content.split('\n').filter(l => l.trim());
+    for (const line of lines) {
+      try {
+        entries.push(JSON.parse(line));
+      } catch {
+        // skip malformed lines
+      }
+    }
+  }
+
+  // Filter by level
+  if (options.errors) {
+    entries = entries.filter(e => e.level === 'Error' || e.level === 'Exception');
+  } else if (options.warnings) {
+    entries = entries.filter(e => e.level === 'Warning');
+  }
+
+  // Limit results
+  if (options.last) {
+    const n = parseInt(options.last, 10) || 20;
+    entries = entries.slice(-n);
+  }
+
+  if (entries.length === 0) {
+    console.log('No matching log entries.');
+    return;
+  }
+
+  // Display
+  console.log(`Showing ${entries.length} log entries:\n`);
+  for (const entry of entries) {
+    const time = entry.timestamp ? new Date(entry.timestamp).toLocaleTimeString() : '??:??';
+    const level = (entry.level || 'Log').padEnd(9);
+    console.log(`[${time}] ${level} ${entry.message}`);
+    if (entry.stackTrace) {
+      console.log(`           ${entry.stackTrace.split('\n')[0]}`);
+    }
+  }
+}

package/src/commands/plugin.js

@@ -0,0 +1,100 @@
+import { PluginManager } from '../plugins/manager.js';
+import { validatePluginRepo, validatePluginName } from '../core/validators.js';
+
+export async function handlePluginAdd(repo) {
+  const rv = validatePluginRepo(repo);
+  if (!rv.valid) {
+    console.error(`✘ ${rv.error}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const pm = new PluginManager(process.cwd());
+  try {
+    const manifest = await pm.add(repo);
+    console.log(`✔ Plugin "${manifest.name}" v${manifest.version} installed`);
+    console.log(`  Engine: ${manifest.engine || 'generic'}`);
+    console.log(`  Run \`uda scan\` to index new knowledge`);
+  } catch (err) {
+    console.error(`✘ Failed to install plugin from "${repo}": ${err.message}`);
+    process.exitCode = 1;
+  }
+}
+
+export async function handlePluginList() {
+  const pm = new PluginManager(process.cwd());
+  let plugins;
+  try {
+    plugins = await pm.list();
+  } catch (err) {
+    console.error(`✘ Failed to list plugins: ${err.message}`);
+    process.exitCode = 1;
+    return;
+  }
+  if (plugins.length === 0) {
+    console.log('No plugins installed. Run `uda plugin add <repo>` to install one.');
+    return;
+  }
+  for (const p of plugins) {
+    console.log(`  ✔ ${p.name || 'unknown'} (v${p.version || '?'}) — ${p.engine || 'generic'}`);
+  }
+}
+
+export async function handlePluginRemove(name) {
+  const nv = validatePluginName(name);
+  if (!nv.valid) {
+    console.error(`✘ ${nv.error}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const pm = new PluginManager(process.cwd());
+  try {
+    const meta = await pm.remove(name);
+    console.log(`✔ Plugin "${meta.name}" removed`);
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      console.error(`✘ Plugin "${name}" is not installed`);
+    } else {
+      console.error(`✘ Failed to remove plugin "${name}": ${err.message}`);
+    }
+    process.exitCode = 1;
+  }
+}
+
+export async function handlePluginUpdate(name) {
+  if (name) {
+    const nv = validatePluginName(name);
+    if (!nv.valid) {
+      console.error(`✘ ${nv.error}`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  const pm = new PluginManager(process.cwd());
+
+  try {
+    if (name) {
+      const result = await pm.update(name);
+      console.log(`✔ Plugin "${result.name}" updated (${result.commitHash?.slice(0, 7) || 'latest'})`);
+    } else {
+      const results = await pm.updateAll();
+      if (results.length === 0) {
+        console.log('No plugins installed.');
+        return;
+      }
+      for (const r of results) {
+        console.log(`  ✔ ${r.name} updated (${r.commitHash?.slice(0, 7) || 'latest'})`);
+      }
+      console.log(`\n✔ ${results.length} plugin(s) updated`);
+    }
+  } catch (err) {
+    if (err.code === 'ENOENT' && name) {
+      console.error(`✘ Plugin "${name}" is not installed`);
+    } else {
+      console.error(`✘ Failed to update plugin${name ? ` "${name}"` : 's'}: ${err.message}`);
+    }
+    process.exitCode = 1;
+  }
+}

package/src/commands/scan.js

@@ -0,0 +1,71 @@
+// src/commands/scan.js
+import { readdir, stat, readFile } from 'fs/promises';
+import { join, relative, extname } from 'path';
+import { RagManager } from '../rag/manager.js';
+import { udaPaths } from '../core/constants.js';
+
+export async function handleScan() {
+  const root = process.cwd();
+  const paths = udaPaths(root);
+
+  let rag;
+  try {
+    rag = new RagManager(paths.rag.lancedb);
+    await rag.init();
+  } catch (err) {
+    console.error(`✘ Failed to initialize RAG engine: ${err.message}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  // Scan .uda/knowledge directory
+  const knowledgeDir = paths.knowledge.root;
+  let files;
+  try {
+    files = await collectMdFiles(knowledgeDir);
+  } catch (err) {
+    console.error(`✘ Failed to collect files from knowledge directory: ${err.message}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (files.length === 0) {
+    console.log('No markdown files found in knowledge directory.');
+    console.log('  Add .md files to .uda/knowledge/ or install a plugin.');
+    return;
+  }
+
+  let totalChunks = 0;
+  for (const file of files) {
+    const relPath = relative(root, file);
+    try {
+      const count = await rag.learnFile(file, { source: relPath });
+      totalChunks += count;
+      console.log(`  ✔ ${relPath} (${count} chunks)`);
+    } catch (err) {
+      console.error(`  ✘ Failed to index ${relPath}: ${err.message}`);
+    }
+  }
+
+  console.log(`\n✔ Scan complete: ${files.length} files, ${totalChunks} chunks indexed`);
+}
+
+async function collectMdFiles(dir) {
+  const results = [];
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...await collectMdFiles(fullPath));
+      } else if (extname(entry.name) === '.md') {
+        results.push(fullPath);
+      }
+    }
+  } catch (err) {
+    if (err.code !== 'ENOENT') {
+      console.error(`✘ Failed to read directory ${dir}: ${err.message}`);
+    }
+  }
+  return results;
+}

package/src/commands/search.js

@@ -0,0 +1,69 @@
+// src/commands/search.js
+import { RagManager } from '../rag/manager.js';
+import { udaPaths } from '../core/constants.js';
+import { validateSearchQuery, validatePositiveInt, validateSearchFormat } from '../core/validators.js';
+
+export async function handleSearch(query, options) {
+  // Validate search query
+  const qv = validateSearchQuery(query);
+  if (!qv.valid) {
+    console.error(`✘ ${qv.error}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  // Validate --top option
+  const tv = validatePositiveInt(options.top, '--top');
+  if (!tv.valid) {
+    console.error(`✘ ${tv.error}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  // Validate --format option
+  if (options.format) {
+    const fv = validateSearchFormat(options.format);
+    if (!fv.valid) {
+      console.error(`✘ ${fv.error}`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  const paths = udaPaths(process.cwd());
+
+  let rag;
+  try {
+    rag = new RagManager(paths.rag.lancedb);
+    await rag.init();
+  } catch (err) {
+    console.error(`✘ Failed to initialize RAG engine: ${err.message}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const limit = tv.value;
+
+  let results;
+  try {
+    results = await rag.search(query, limit);
+  } catch (err) {
+    console.error(`✘ Search failed: ${err.message}`);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (results.length === 0) {
+    console.log('No results found.');
+    return;
+  }
+
+  results.forEach((r, i) => {
+    const distance = typeof r.score === 'number' && !isNaN(r.score) ? r.score : 0;
+    const score = (1 - distance).toFixed(2); // convert distance to similarity
+    console.log(`\n${i + 1}. [${(score * 100).toFixed(0)}%] ${r.source || 'unknown'}`);
+    console.log(`   ${(r.content || '').slice(0, 120)}...`);
+    const tags = Array.isArray(r.tags) ? r.tags : [];
+    if (tags.length > 0) console.log(`   Tags: ${tags.join(', ')}`);
+  });
+}

package/src/commands/status.js

@@ -0,0 +1,74 @@
+// src/commands/status.js
+import { readFile, readdir, access } from 'fs/promises';
+import { join } from 'path';
+import { udaPaths } from '../core/constants.js';
+import { loadConfig } from '../core/config.js';
+import { VectorStore } from '../rag/store.js';
+
+export async function handleStatus() {
+  const root = process.cwd();
+  const paths = udaPaths(root);
+
+  // Check if UDA is initialized
+  try {
+    await access(paths.config);
+  } catch {
+    console.error('✘ UDA is not initialized. Run `uda init` first.');
+    process.exitCode = 1;
+    return;
+  }
+
+  let config;
+  try {
+    config = await loadConfig(root);
+  } catch (err) {
+    console.error(`✘ Failed to read config file: ${err.message}`);
+    process.exitCode = 1;
+    return;
+  }
+  console.log(`UDA v${config.version || 'unknown'}\n`);
+
+  // Plugins
+  try {
+    const pluginFiles = await readdir(paths.plugins);
+    const plugins = pluginFiles.filter(f => f.endsWith('.json'));
+    console.log(`Plugins: ${plugins.length > 0 ? plugins.map(f => f.replace('.json', '')).join(', ') : 'none'}`);
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      console.log('Plugins: none');
+    } else {
+      console.error(`Plugins: failed to read (${err.message})`);
+    }
+  }
+
+  // RAG stats
+  try {
+    const store = new VectorStore(paths.rag.lancedb);
+    await store.init();
+    const count = await store.count();
+    console.log(`RAG index: ${count} chunks`);
+  } catch (err) {
+    if (err.code === 'ENOENT' || err.message?.includes('Table') || err.message?.includes('does not exist')) {
+      console.log('RAG index: not initialized');
+    } else {
+      console.error(`RAG index: failed to read (${err.message})`);
+    }
+  }
+
+  // Adapters
+  const adapters = Array.isArray(config.adapters) ? config.adapters : [];
+  console.log(`Adapters: ${adapters.length > 0 ? adapters.join(', ') : 'none configured'}`);
+
+  // State
+  try {
+    const state = await readFile(paths.state.current, 'utf8');
+    const lines = state.split('\n').slice(0, 5).join('\n');
+    console.log(`\n--- Current State ---\n${lines}`);
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      console.log('\nNo state file.');
+    } else {
+      console.error(`\n✘ Failed to read state file: ${err.message}`);
+    }
+  }
+}

package/src/commands/sync.js

@@ -0,0 +1,84 @@
+// src/commands/sync.js
+import { readFile, writeFile, mkdir, readdir } from 'fs/promises';
+import { join, dirname } from 'path';
+import { udaPaths } from '../core/constants.js';
+import { loadConfig } from '../core/config.js';
+import { loadKnowledge, loadWorkflows, loadAgents } from '../core/knowledge-loader.js';
+import { ClaudeAdapter } from '../adapters/claude.js';
+import { CursorAdapter } from '../adapters/cursor.js';
+import { RawAdapter } from '../adapters/raw.js';
+import { AgentsMdAdapter } from '../adapters/agents-md.js';
+
+const ALL_ADAPTERS = [
+  new ClaudeAdapter(),
+  new CursorAdapter(),
+  new RawAdapter(),
+  new AgentsMdAdapter(),
+];
+
+export async function handleSync() {
+  const root = process.cwd();
+  const paths = udaPaths(root);
+
+  let config, knowledge, workflows, agents;
+  try {
+    config = await loadConfig(root);
+    knowledge = await loadKnowledge(paths);
+    workflows = await loadWorkflows(paths);
+    agents = await loadAgents(paths);
+  } catch (err) {
+    console.error(`✘ Failed to load project data: ${err.message}`);
+    console.error('  Run `uda init` to initialize the project.');
+    process.exitCode = 1;
+    return;
+  }
+
+  // Load merged capabilities from all installed plugins
+  const capabilities = await loadCapabilities(paths);
+
+  const adapterList = Array.isArray(config.adapters) ? config.adapters : [];
+  const activeAdapters = adapterList.length > 0
+    ? ALL_ADAPTERS.filter(a => adapterList.includes(a.name))
+    : ALL_ADAPTERS;
+
+  if (activeAdapters.length === 0) {
+    console.log('No matching adapters found. Check config.adapters setting.');
+    return;
+  }
+
+  let totalFiles = 0;
+
+  for (const adapter of activeAdapters) {
+    try {
+      const files = adapter.generate(knowledge, workflows, agents, root, capabilities);
+      for (const [filePath, content] of Object.entries(files)) {
+        const fullPath = join(root, filePath);
+        await mkdir(dirname(fullPath), { recursive: true });
+        await writeFile(fullPath, content);
+        totalFiles++;
+      }
+      console.log(`  ✔ ${adapter.name} adapter — ${Object.keys(files).length} files`);
+    } catch (err) {
+      console.error(`  ✘ ${adapter.name} adapter failed: ${err.message}`);
+    }
+  }
+
+  console.log(`\n✔ Sync complete: ${totalFiles} files generated`);
+}
+
+async function loadCapabilities(paths) {
+  const merged = {};
+  try {
+    const files = await readdir(paths.plugins);
+    for (const f of files) {
+      if (!f.endsWith('.json')) continue;
+      try {
+        const meta = JSON.parse(await readFile(join(paths.plugins, f), 'utf8'));
+        if (meta.capabilities) {
+          Object.assign(merged, meta.capabilities);
+        }
+      } catch { /* skip malformed */ }
+    }
+  } catch { /* no plugins dir */ }
+  return merged;
+}

package/src/core/config.js

@@ -0,0 +1,47 @@
+// src/core/config.js
+import { readFile, writeFile } from 'fs/promises';
+import { udaPaths } from './constants.js';
+
+export async function loadConfig(root) {
+  const paths = udaPaths(root);
+  return JSON.parse(await readFile(paths.config, 'utf8'));
+}
+
+export async function saveConfig(root, config) {
+  const paths = udaPaths(root);
+  await writeFile(paths.config, JSON.stringify(config, null, 2));
+}
+
+export function getConfigValue(config, key) {
+  const parts = key.split('.');
+  let current = config;
+  for (const part of parts) {
+    if (current == null || typeof current !== 'object') return undefined;
+    current = current[part];
+  }
+  return current;
+}
+
+export function setConfigValue(config, key, value) {
+  const parts = key.split('.');
+  let current = config;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (current[parts[i]] == null || typeof current[parts[i]] !== 'object') {
+      current[parts[i]] = {};
+    }
+    current = current[parts[i]];
+  }
+  current[parts[parts.length - 1]] = parseValue(value);
+}
+
+function parseValue(value) {
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+  if (value === 'null') return null;
+  if (/^\d+$/.test(value)) return parseInt(value, 10);
+  if (/^\d+\.\d+$/.test(value)) return parseFloat(value);
+  if (value.startsWith('[') && value.endsWith(']')) {
+    return value.slice(1, -1).split(',').map(s => s.trim());
+  }
+  return value;
+}

package/src/core/constants.js

@@ -0,0 +1,34 @@
+// src/core/constants.js
+import { join } from 'path';
+
+export const UDA_DIR = '.uda';
+
+export function udaPaths(root) {
+  const uda = join(root, UDA_DIR);
+  return {
+    root: uda,
+    config: join(uda, 'config.json'),
+    knowledge: {
+      root: join(uda, 'knowledge'),
+      engine: join(uda, 'knowledge', 'engine'),
+      project: join(uda, 'knowledge', 'project'),
+      community: join(uda, 'knowledge', 'community'),
+    },
+    workflows: join(uda, 'workflows'),
+    agents: join(uda, 'agents'),
+    state: {
+      root: join(uda, 'state'),
+      current: join(uda, 'state', 'current.md'),
+      features: join(uda, 'state', 'features'),
+      history: join(uda, 'state', 'history'),
+    },
+    rag: {
+      root: join(uda, 'rag'),
+      lancedb: join(uda, 'rag', 'lancedb'),
+      cache: join(uda, 'rag', 'cache'),
+    },
+    plugins: join(uda, 'plugins'),
+    generated: join(uda, '.generated'),
+    logs: join(uda, 'logs'),
+  };
+}