uda-cli 0.2.0

package/src/core/init.js

@@ -0,0 +1,86 @@
+// src/core/init.js
+import { mkdir, writeFile, access } from 'fs/promises';
+import { udaPaths } from './constants.js';
+
+const DEFAULT_CONFIG = {
+  version: '0.1.0',
+  language: 'en',
+  adapters: ['claude', 'cursor', 'windsurf', 'agents-md', 'raw'],
+  plugins: [],
+  rag: {
+    embedding_model: 'Xenova/all-MiniLM-L6-v2',
+    chunk_size: 512,
+    chunk_overlap: 50,
+  },
+};
+
+const INITIAL_STATE = `# Project State
+
+## Last Updated: ${new Date().toISOString().split('T')[0]}
+
+## Active Work
+None yet. Run \`uda scan\` to index your project.
+
+## Completed
+- [x] UDA initialized
+
+## Decisions
+(Architectural decisions will be recorded here)
+`;
+
+export async function initProject(root) {
+  const paths = udaPaths(root);
+
+  // Create all directories
+  const dirs = [
+    paths.root,
+    paths.knowledge.root,
+    paths.knowledge.engine,
+    paths.knowledge.project,
+    paths.knowledge.community,
+    paths.workflows,
+    paths.agents,
+    paths.state.root,
+    paths.state.features,
+    paths.state.history,
+    paths.rag.root,
+    paths.rag.lancedb,
+    paths.rag.cache,
+    paths.plugins,
+    paths.generated,
+  ];
+
+  for (const dir of dirs) {
+    await mkdir(dir, { recursive: true });
+  }
+
+  // Create config.json (skip if exists)
+  const configExists = await fileExists(paths.config);
+  if (!configExists) {
+    await writeFile(paths.config, JSON.stringify(DEFAULT_CONFIG, null, 2));
+  }
+
+  // Create initial state
+  const stateExists = await fileExists(paths.state.current);
+  if (!stateExists) {
+    await writeFile(paths.state.current, INITIAL_STATE);
+  }
+
+  // Create .gitignore for rag and generated
+  const gitignorePath = `${paths.root}/.gitignore`;
+  const gitignoreExists = await fileExists(gitignorePath);
+  if (!gitignoreExists) {
+    await writeFile(gitignorePath, 'rag/\n.generated/\n');
+  }
+
+  return paths;
+}
+
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/core/knowledge-loader.js

@@ -0,0 +1,93 @@
+// src/core/knowledge-loader.js
+import { readFile, readdir } from 'fs/promises';
+import { join } from 'path';
+import { parse as parseYaml } from 'yaml';
+
+export async function loadKnowledge(paths) {
+  const knowledge = { project: {}, conventions: [], decisions: [] };
+
+  try {
+    const profile = await readFile(join(paths.knowledge.project, 'profile.md'), 'utf8');
+    const nameMatch = profile.match(/Project:\s*(.+)/i);
+    const engineMatch = profile.match(/Engine:\s*(.+)/i);
+    if (nameMatch) knowledge.project.name = nameMatch[1].trim();
+    if (engineMatch) knowledge.project.engine = engineMatch[1].trim();
+  } catch (err) {
+    if (err.code !== 'ENOENT') {
+      console.error(`Warning: Failed to read project profile: ${err.message}`);
+    }
+  }
+
+  try {
+    const decisions = await readFile(join(paths.knowledge.project, 'decisions.md'), 'utf8');
+    knowledge.decisions = decisions.split('\n')
+      .filter(l => l.startsWith('- '))
+      .map(l => l.slice(2));
+  } catch (err) {
+    if (err.code !== 'ENOENT') {
+      console.error(`Warning: Failed to read decisions file: ${err.message}`);
+    }
+  }
+
+  return knowledge;
+}
+
+export async function loadWorkflows(paths) {
+  const workflows = [];
+  let files;
+  try {
+    files = await readdir(paths.workflows);
+  } catch (err) {
+    if (err.code === 'ENOENT') return [];
+    throw err;
+  }
+
+  for (const file of files) {
+    if (!file.endsWith('.yaml') && !file.endsWith('.yml')) continue;
+    try {
+      const content = await readFile(join(paths.workflows, file), 'utf8');
+      const parsed = parseYaml(content);
+      if (parsed && parsed.name) {
+        workflows.push(parsed);
+      }
+    } catch (err) {
+      console.error(`Warning: Failed to parse workflow "${file}": ${err.message}`);
+    }
+  }
+
+  return workflows;
+}
+
+export async function loadAgents(paths) {
+  const agents = [];
+  let files;
+  try {
+    files = await readdir(paths.agents);
+  } catch (err) {
+    if (err.code === 'ENOENT') return [];
+    throw err;
+  }
+
+  for (const file of files) {
+    if (!file.endsWith('.md')) continue;
+    try {
+      const content = await readFile(join(paths.agents, file), 'utf8');
+      const agent = parseFrontmatter(content);
+      if (agent.name) {
+        agents.push(agent);
+      }
+    } catch (err) {
+      console.error(`Warning: Failed to parse agent "${file}": ${err.message}`);
+    }
+  }
+
+  return agents;
+}
+
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  if (!match) return { prompt: content };
+
+  const meta = parseYaml(match[1]);
+  return { ...meta, prompt: match[2].trim() };
+}

package/src/core/validators.js

@@ -0,0 +1,123 @@
+// src/core/validators.js
+
+const VALID_ENGINES = ['unity', 'godot', 'unreal'];
+const VALID_LEARN_TYPES = ['bug-fix', 'feature', 'pattern', 'knowledge'];
+const VALID_EXPORT_FORMATS = ['claude', 'cursor', 'agents-md', 'raw'];
+const VALID_SEARCH_FORMATS = ['terminal', 'md', 'clipboard'];
+
+/**
+ * Validate result: { valid: true } or { valid: false, error: string }
+ */
+
+export function validateEngine(engine) {
+  if (typeof engine !== 'string' || engine.trim() === '') {
+    return { valid: false, error: 'Engine name must be a non-empty string.' };
+  }
+  if (!VALID_ENGINES.includes(engine)) {
+    return { valid: false, error: `Unknown engine "${engine}". Valid engines: ${VALID_ENGINES.join(', ')}` };
+  }
+  return { valid: true };
+}
+
+export function validateConfigKey(key) {
+  if (typeof key !== 'string' || key.trim() === '') {
+    return { valid: false, error: 'Config key must be a non-empty string.' };
+  }
+  if (!/^[a-zA-Z0-9_]+(\.[a-zA-Z0-9_]+)*$/.test(key)) {
+    return { valid: false, error: `Invalid config key "${key}". Use dot notation (e.g. "rag.enabled").` };
+  }
+  return { valid: true };
+}
+
+export function validateExportFormat(format) {
+  if (typeof format !== 'string' || format.trim() === '') {
+    return { valid: false, error: 'Export format must be a non-empty string.' };
+  }
+  if (!VALID_EXPORT_FORMATS.includes(format)) {
+    return { valid: false, error: `Unknown format "${format}". Available: ${VALID_EXPORT_FORMATS.join(', ')}` };
+  }
+  return { valid: true };
+}
+
+export function validatePluginRepo(repo) {
+  if (typeof repo !== 'string' || repo.trim() === '') {
+    return { valid: false, error: 'Plugin repository URL must be a non-empty string.' };
+  }
+  const gitUrlPattern = /^(https?:\/\/.+\.git|git@.+:.+\.git|[a-zA-Z0-9_-]+\/[a-zA-Z0-9_.-]+)$/;
+  if (!gitUrlPattern.test(repo.trim())) {
+    return { valid: false, error: `Invalid repository URL "${repo}". Expected a git URL (e.g. https://github.com/user/repo.git) or shorthand (user/repo).` };
+  }
+  return { valid: true };
+}
+
+export function validatePluginName(name) {
+  if (typeof name !== 'string' || name.trim() === '') {
+    return { valid: false, error: 'Plugin name must be a non-empty string.' };
+  }
+  if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+    return { valid: false, error: `Invalid plugin name "${name}". Use only letters, numbers, hyphens and underscores.` };
+  }
+  return { valid: true };
+}
+
+export function validateLearnType(type) {
+  if (typeof type !== 'string' || type.trim() === '') {
+    return { valid: false, error: 'Learn type must be a non-empty string.' };
+  }
+  if (!VALID_LEARN_TYPES.includes(type)) {
+    return { valid: false, error: `Unknown type "${type}". Valid types: ${VALID_LEARN_TYPES.join(', ')}` };
+  }
+  return { valid: true };
+}
+
+export function validateSearchQuery(query) {
+  if (typeof query !== 'string' || query.trim() === '') {
+    return { valid: false, error: 'Search query must be a non-empty string.' };
+  }
+  return { valid: true };
+}
+
+export function validatePositiveInt(value, name) {
+  const parsed = parseInt(value, 10);
+  if (isNaN(parsed) || parsed < 1) {
+    return { valid: false, error: `${name} must be a positive integer. Got "${value}".` };
+  }
+  return { valid: true, value: parsed };
+}
+
+export function validateSearchFormat(format) {
+  if (typeof format !== 'string' || format.trim() === '') {
+    return { valid: false, error: 'Search format must be a non-empty string.' };
+  }
+  if (!VALID_SEARCH_FORMATS.includes(format)) {
+    return { valid: false, error: `Unknown search format "${format}". Available: ${VALID_SEARCH_FORMATS.join(', ')}` };
+  }
+  return { valid: true };
+}
+
+const MANIFEST_REQUIRED = ['name', 'version', 'engine', 'uda_version'];
+
+export function validateManifest(manifest) {
+  if (!manifest || typeof manifest !== 'object') {
+    return { valid: false, error: 'Manifest must be a JSON object.' };
+  }
+
+  for (const field of MANIFEST_REQUIRED) {
+    if (!manifest[field] || typeof manifest[field] !== 'string') {
+      return { valid: false, error: `Manifest must include a "${field}" string field.` };
+    }
+  }
+
+  if (manifest.capabilities && typeof manifest.capabilities === 'object') {
+    const caps = manifest.capabilities;
+    if (caps.logs && typeof caps.logs === 'object') {
+      if (!caps.logs.source || typeof caps.logs.source !== 'string') {
+        return { valid: false, error: 'Capability "logs" must include a "source" path string.' };
+      }
+    }
+  }
+
+  return { valid: true };
+}
+
+export { VALID_ENGINES, VALID_LEARN_TYPES, VALID_EXPORT_FORMATS, VALID_SEARCH_FORMATS };

package/src/plugins/manager.js

@@ -0,0 +1,160 @@
+import { simpleGit } from 'simple-git';
+import { readFile, writeFile, rm, readdir, mkdir, cp } from 'fs/promises';
+import { join, basename } from 'path';
+import { udaPaths } from '../core/constants.js';
+import { validateManifest } from '../core/validators.js';
+
+export class PluginManager {
+  constructor(projectRoot) {
+    this.root = projectRoot;
+    this.paths = udaPaths(projectRoot);
+  }
+
+  async add(repoUrl) {
+    const tmpDir = join(this.paths.root, '.tmp-plugin');
+    const git = simpleGit();
+
+    try {
+      // Clone repo
+      await git.clone(repoUrl, tmpDir, ['--depth', '1']);
+
+      // Get commit hash
+      const log = await git.cwd(tmpDir).log(['-1']);
+      const commitHash = log.latest?.hash || 'unknown';
+
+      // Read manifest
+      let manifestRaw;
+      try {
+        manifestRaw = await readFile(join(tmpDir, 'manifest.json'), 'utf8');
+      } catch (err) {
+        throw new Error(`Plugin repository is missing manifest.json`);
+      }
+
+      let manifest;
+      try {
+        manifest = JSON.parse(manifestRaw);
+      } catch (err) {
+        throw new Error(`Plugin manifest.json contains invalid JSON: ${err.message}`);
+      }
+
+      // Validate manifest
+      const validation = validateManifest(manifest);
+      if (!validation.valid) {
+        throw new Error(`Invalid plugin manifest: ${validation.error}`);
+      }
+
+      const pluginName = manifest.name;
+
+      // Copy knowledge files
+      const knowledgeDir = join(tmpDir, 'knowledge');
+      const targetKnowledge = join(this.paths.knowledge.engine, manifest.engine || pluginName);
+      await mkdir(targetKnowledge, { recursive: true });
+      await cpDir(knowledgeDir, targetKnowledge);
+
+      // Copy workflows
+      const workflowDir = join(tmpDir, 'workflows');
+      await cpDir(workflowDir, this.paths.workflows);
+
+      // Copy agents
+      const agentDir = join(tmpDir, 'agents');
+      await cpDir(agentDir, this.paths.agents);
+
+      // Copy editor files (e.g., UdaLogBridge.cs → Assets/Editor/)
+      if (manifest.capabilities?.logs?.bridge && manifest.capabilities?.logs?.install_to) {
+        const bridgeSrc = join(tmpDir, manifest.capabilities.logs.bridge);
+        const bridgeDest = join(this.root, manifest.capabilities.logs.install_to);
+        await mkdir(bridgeDest, { recursive: true });
+        await cp(bridgeSrc, join(bridgeDest, basename(manifest.capabilities.logs.bridge)));
+      }
+
+      // Save plugin metadata
+      const pluginMeta = {
+        ...manifest,
+        repo: repoUrl,
+        installedAt: new Date().toISOString(),
+        commitHash,
+      };
+      await writeFile(
+        join(this.paths.plugins, `${manifest.engine || pluginName}.json`),
+        JSON.stringify(pluginMeta, null, 2)
+      );
+
+      return manifest;
+    } finally {
+      await rm(tmpDir, { recursive: true, force: true });
+    }
+  }
+
+  async list() {
+    try {
+      const files = await readdir(this.paths.plugins);
+      const plugins = [];
+      for (const f of files) {
+        if (f.endsWith('.json')) {
+          try {
+            const data = JSON.parse(await readFile(join(this.paths.plugins, f), 'utf8'));
+            plugins.push(data);
+          } catch (err) {
+            console.error(`Warning: Failed to read plugin metadata "${f}": ${err.message}`);
+          }
+        }
+      }
+      return plugins;
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        console.error(`Warning: Failed to list plugins: ${err.message}`);
+      }
+      return [];
+    }
+  }
+
+  async remove(name) {
+    const metaPath = join(this.paths.plugins, `${name}.json`);
+    const meta = JSON.parse(await readFile(metaPath, 'utf8'));
+
+    // Remove engine knowledge
+    const engineDir = join(this.paths.knowledge.engine, meta.engine || name);
+    await rm(engineDir, { recursive: true, force: true });
+
+    // Remove metadata
+    await rm(metaPath);
+
+    return meta;
+  }
+
+  async update(name) {
+    const metaPath = join(this.paths.plugins, `${name}.json`);
+    const meta = JSON.parse(await readFile(metaPath, 'utf8'));
+
+    // Remove old files and metadata
+    await this.remove(name);
+
+    // Re-add from repo
+    const newManifest = await this.add(meta.repo);
+
+    return { old: meta, new: newManifest };
+  }
+
+  async updateAll() {
+    const plugins = await this.list();
+    const results = [];
+
+    for (const plugin of plugins) {
+      const name = plugin.engine || plugin.name;
+      const result = await this.update(name);
+      results.push({ name, ...result });
+    }
+
+    return results;
+  }
+}
+
+async function cpDir(src, dest) {
+  try {
+    await cp(src, dest, { recursive: true });
+  } catch (err) {
+    if (err.code !== 'ENOENT') {
+      console.error(`Warning: Failed to copy "${src}" to "${dest}": ${err.message}`);
+    }
+  }
+}

package/src/rag/chunker.js

@@ -0,0 +1,86 @@
+// src/rag/chunker.js
+
+export function chunkMarkdown(text, options = {}) {
+  const {
+    source = 'unknown',
+    engine = null,
+    tags = [],
+    type = 'knowledge',
+    maxChunkSize = 512,
+  } = options;
+
+  const baseMetadata = { source, engine, tags, type, date: new Date().toISOString().split('T')[0] };
+  const chunks = [];
+  const lines = text.split('\n');
+
+  let currentChunk = { heading: '', lines: [], type: 'text' };
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Code block detection
+    if (line.startsWith('```')) {
+      // Flush current text chunk
+      if (currentChunk.lines.length > 0) {
+        chunks.push(buildChunk(currentChunk, baseMetadata, maxChunkSize));
+        currentChunk = { heading: currentChunk.heading, lines: [], type: 'text' };
+      }
+
+      // Collect code block
+      const codeLines = [line];
+      i++;
+      while (i < lines.length && !lines[i].startsWith('```')) {
+        codeLines.push(lines[i]);
+        i++;
+      }
+      if (i < lines.length) codeLines.push(lines[i]); // closing ```
+
+      chunks.push({
+        content: codeLines.join('\n'),
+        type: 'code',
+        metadata: { ...baseMetadata },
+      });
+      continue;
+    }
+
+    // Heading detection
+    if (line.match(/^#{1,6}\s/)) {
+      // Flush previous chunk
+      if (currentChunk.lines.length > 0) {
+        chunks.push(buildChunk(currentChunk, baseMetadata, maxChunkSize));
+      }
+      currentChunk = { heading: line, lines: [line], type: 'text' };
+      continue;
+    }
+
+    currentChunk.lines.push(line);
+  }
+
+  // Flush last chunk
+  if (currentChunk.lines.length > 0) {
+    chunks.push(buildChunk(currentChunk, baseMetadata, maxChunkSize));
+  }
+
+  return chunks;
+}
+
+function buildChunk(chunk, baseMetadata, maxChunkSize) {
+  const content = chunk.lines.join('\n').trim();
+
+  // If within size limit, return as-is
+  if (content.length <= maxChunkSize) {
+    return {
+      content,
+      type: chunk.type,
+      metadata: { ...baseMetadata },
+    };
+  }
+
+  // Split oversized chunks by paragraph
+  // For simplicity, return single chunk trimmed (full split in future)
+  return {
+    content: content.slice(0, maxChunkSize),
+    type: chunk.type,
+    metadata: { ...baseMetadata },
+  };
+}

package/src/rag/embedder.js

@@ -0,0 +1,29 @@
+import { pipeline } from '@xenova/transformers';
+
+export class Embedder {
+  constructor(modelName = 'Xenova/all-MiniLM-L6-v2') {
+    this.modelName = modelName;
+    this.extractor = null;
+  }
+
+  async init() {
+    if (!this.extractor) {
+      this.extractor = await pipeline('feature-extraction', this.modelName);
+    }
+  }
+
+  async embed(text) {
+    await this.init();
+    const output = await this.extractor(text, { pooling: 'mean', normalize: true });
+    return Array.from(output.data);
+  }
+
+  async embedBatch(texts) {
+    await this.init();
+    const results = [];
+    for (const text of texts) {
+      results.push(await this.embed(text));
+    }
+    return results;
+  }
+}

package/src/rag/manager.js

@@ -0,0 +1,56 @@
+// src/rag/manager.js
+import { readFile } from 'fs/promises';
+import { basename } from 'path';
+import { chunkMarkdown } from './chunker.js';
+import { Embedder } from './embedder.js';
+import { VectorStore } from './store.js';
+
+export class RagManager {
+  constructor(dbPath) {
+    this.embedder = new Embedder();
+    this.store = new VectorStore(dbPath);
+  }
+
+  async init() {
+    await this.embedder.init();
+    await this.store.init();
+  }
+
+  async learnFile(filePath, options = {}) {
+    const content = await readFile(filePath, 'utf8');
+    const source = options.source || basename(filePath);
+    const chunks = chunkMarkdown(content, { source, ...options });
+
+    await this._indexChunks(chunks);
+    return chunks.length;
+  }
+
+  async learnText(text, options = {}) {
+    const chunks = chunkMarkdown(text, { source: 'manual', ...options });
+    await this._indexChunks(chunks);
+    return chunks.length;
+  }
+
+  async search(query, limit = 5) {
+    const queryVector = await this.embedder.embed(query);
+    return await this.store.search(queryVector, limit);
+  }
+
+  async _indexChunks(chunks) {
+    const documents = [];
+
+    for (const chunk of chunks) {
+      const vector = await this.embedder.embed(chunk.content);
+      documents.push({
+        id: `${chunk.metadata.source}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        content: chunk.content,
+        vector,
+        metadata: chunk.metadata,
+      });
+    }
+
+    if (documents.length > 0) {
+      await this.store.add(documents);
+    }
+  }
+}