@useconductor/conductor 1.0.0

package/src/plugins/builtin/lumen.ts

@@ -0,0 +1,497 @@
+import { Plugin, PluginTool, PluginConfigSchema } from '../manager.js';
+import { Conductor } from '../../core/conductor.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { dirname } from 'path';
+import { z } from 'zod';
+
+const execAsync = promisify(exec);
+
+// ── Zod schemas for executeTool args ─────────────────────────────────────────
+
+const RunShellArgsSchema = z.object({
+  command: z.string().min(1, 'command is required'),
+  working_dir: z.string().optional(),
+  timeout: z.number().int().positive().optional(),
+});
+
+const ReadFileArgsSchema = z.object({
+  path: z.string().min(1, 'path is required'),
+});
+
+const WriteFileArgsSchema = z.object({
+  path: z.string().min(1, 'path is required'),
+  content: z.string(),
+});
+
+// ── Ollama API response types ─────────────────────────────────────────────────
+
+interface OllamaToolCallFunction {
+  name: string;
+  arguments: string | Record<string, unknown>;
+}
+
+interface OllamaToolCall {
+  function: OllamaToolCallFunction;
+}
+
+interface OllamaMessage {
+  role: string;
+  content: string | null;
+  tool_calls?: OllamaToolCall[];
+}
+
+interface OllamaResponse {
+  message: OllamaMessage;
+}
+
+const LUMEN_TOOLS = [
+  {
+    type: 'function',
+    function: {
+      name: 'run_shell',
+      description: 'Run a shell command and return stdout/stderr.',
+      parameters: {
+        type: 'object',
+        properties: {
+          command: { type: 'string' },
+          working_dir: { type: 'string' },
+          timeout: { type: 'integer' },
+        },
+        required: ['command'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'read_file',
+      description: 'Read the contents of a file.',
+      parameters: {
+        type: 'object',
+        properties: { path: { type: 'string' } },
+        required: ['path'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'write_file',
+      description: 'Write content to a file, creating directories as needed.',
+      parameters: {
+        type: 'object',
+        properties: {
+          path: { type: 'string' },
+          content: { type: 'string' },
+        },
+        required: ['path', 'content'],
+      },
+    },
+  },
+];
+
+const LUMEN_SYSTEM = `You are Lumen, an agentic AI coding assistant built by Alexander (TheAlxLabs). You run inside Conductor. You have access to tools: run_shell, read_file, write_file. Think step-by-step. Always use tools to verify your work. Be concise in explanations but thorough in execution.`;
+
+async function executeTool(name: string, args: unknown): Promise<string> {
+  if (name === 'run_shell') {
+    const parsed = RunShellArgsSchema.safeParse(args);
+    if (!parsed.success) {
+      return JSON.stringify({
+        error: `Invalid run_shell args: ${parsed.error.issues.map((i) => i.message).join(', ')}`,
+        returncode: 1,
+      });
+    }
+    const { command, working_dir, timeout } = parsed.data;
+    try {
+      const { stdout, stderr } = await execAsync(command, {
+        cwd: working_dir || process.cwd(),
+        timeout: (timeout ?? 30) * 1000,
+      });
+      return JSON.stringify({ stdout, stderr, returncode: 0 });
+    } catch (e: unknown) {
+      const err = e as { stdout?: string; stderr?: string; message?: string; code?: number };
+      return JSON.stringify({
+        stdout: err.stdout || '',
+        stderr: err.stderr || err.message,
+        returncode: err.code || 1,
+      });
+    }
+  }
+
+  if (name === 'read_file') {
+    const parsed = ReadFileArgsSchema.safeParse(args);
+    if (!parsed.success) {
+      return JSON.stringify({
+        error: `Invalid read_file args: ${parsed.error.issues.map((i) => i.message).join(', ')}`,
+        success: false,
+      });
+    }
+    try {
+      const content = await readFile(parsed.data.path, 'utf8');
+      return JSON.stringify({ content, success: true });
+    } catch (e: unknown) {
+      return JSON.stringify({ error: (e as Error).message, success: false });
+    }
+  }
+
+  if (name === 'write_file') {
+    const parsed = WriteFileArgsSchema.safeParse(args);
+    if (!parsed.success) {
+      return JSON.stringify({
+        error: `Invalid write_file args: ${parsed.error.issues.map((i) => i.message).join(', ')}`,
+        success: false,
+      });
+    }
+    const { path, content } = parsed.data;
+    try {
+      await mkdir(dirname(path), { recursive: true });
+      await writeFile(path, content, 'utf8');
+      return JSON.stringify({ success: true, path });
+    } catch (e: unknown) {
+      return JSON.stringify({ error: (e as Error).message, success: false });
+    }
+  }
+
+  return JSON.stringify({ error: `Unknown tool: ${name}` });
+}
+
+export async function runLumenAgent(
+  task: string,
+  endpoint: string,
+  model: string,
+  maxIterations = 10,
+): Promise<{ result: string; iterations: number; toolCalls: string[] }> {
+  const messages: OllamaMessage[] = [
+    { role: 'system', content: LUMEN_SYSTEM },
+    { role: 'user', content: task },
+  ];
+
+  const toolCallLog: string[] = [];
+  let iterations = 0;
+
+  while (iterations < maxIterations) {
+    iterations++;
+
+    const response = await fetch(`${endpoint}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model,
+        messages,
+        tools: LUMEN_TOOLS,
+        stream: false,
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Lumen API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = (await response.json()) as OllamaResponse;
+    const message = data.message;
+    messages.push(message);
+
+    // No tool calls — Lumen is done
+    if (!message.tool_calls || message.tool_calls.length === 0) {
+      return {
+        result: message.content || '(no response)',
+        iterations,
+        toolCalls: toolCallLog,
+      };
+    }
+
+    // Execute each tool call
+    for (const toolCall of message.tool_calls) {
+      const name = toolCall.function.name;
+      const args =
+        typeof toolCall.function.arguments === 'string'
+          ? JSON.parse(toolCall.function.arguments)
+          : toolCall.function.arguments;
+
+      const logEntry = `${name}(${JSON.stringify(args)})`;
+      toolCallLog.push(logEntry);
+      process.stderr.write(`[Lumen] → ${logEntry}\n`);
+
+      const result = await executeTool(name, args);
+      process.stderr.write(`[Lumen] ← ${result.slice(0, 150)}\n`);
+
+      messages.push({ role: 'tool', content: result });
+    }
+  }
+
+  return {
+    result: 'Max iterations reached without a final answer.',
+    iterations,
+    toolCalls: toolCallLog,
+  };
+}
+
+export class LumenPlugin implements Plugin {
+  name = 'lumen';
+  description =
+    'Lumen — agentic AI coding assistant by TheAlxLabs. Writes code, runs shell commands, uses git/GitHub autonomously.';
+  version = '1.0.0';
+
+  private endpoint = 'http://localhost:11434';
+  private model = 'lumen';
+
+  configSchema: PluginConfigSchema = {
+    fields: [
+      {
+        key: 'endpoint',
+        label: 'Ollama Endpoint',
+        type: 'string',
+        description: 'URL where Ollama is running (default: http://localhost:11434)',
+        required: false,
+      },
+      {
+        key: 'model',
+        label: 'Model Name',
+        type: 'string',
+        description: 'Ollama model name to use (default: lumen)',
+        required: false,
+      },
+    ],
+    setupInstructions: `
+Lumen Setup:
+1. Install Ollama: brew install ollama
+2. Pull Lumen: ollama pull thealxlabs/lumen
+   OR import from GGUF: ollama create lumen -f Lumen.Modelfile
+3. Start Ollama: ollama serve
+4. Enable this plugin: conductor plugin enable lumen
+`,
+  };
+
+  async initialize(conductor: Conductor): Promise<void> {
+    const config = conductor.getConfig();
+    this.endpoint = config.get<string>('plugins.lumen.endpoint') || 'http://localhost:11434';
+    this.model = config.get<string>('plugins.lumen.model') || 'lumen';
+
+    // Verify Ollama is reachable
+    const ok = await this.ping();
+    if (!ok) {
+      throw new Error(`Lumen: Cannot reach Ollama at ${this.endpoint}. Run: ollama serve`);
+    }
+
+    // Check if the model exists
+    const models = await this.listModels();
+    if (!models.some((m) => m.includes(this.model))) {
+      throw new Error(`Lumen: Model "${this.model}" not found in Ollama. Run: ollama pull thealxlabs/lumen`);
+    }
+  }
+
+  isConfigured(): boolean {
+    return true; // Config is optional — uses defaults
+  }
+
+  private async ping(): Promise<boolean> {
+    try {
+      const res = await fetch(`${this.endpoint}/api/tags`);
+      return res.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  private async listModels(): Promise<string[]> {
+    try {
+      const res = await fetch(`${this.endpoint}/api/tags`);
+      const data = (await res.json()) as { models?: { name: string }[] };
+      return data.models?.map((m) => m.name) ?? [];
+    } catch {
+      return [];
+    }
+  }
+
+  getTools(): PluginTool[] {
+    return [
+      // ── Main agent tool ───────────────────────────────────────────────
+      {
+        name: 'lumen_ask',
+        description:
+          'Ask Lumen to complete a coding task autonomously. Lumen can write code, run shell commands, use git, fix bugs, and more.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            task: {
+              type: 'string',
+              description: 'The task for Lumen to complete, e.g. "commit all changes with message fix: auth"',
+            },
+            max_iterations: {
+              type: 'number',
+              description: 'Max agentic loop iterations (default: 10)',
+            },
+          },
+          required: ['task'],
+        },
+        requiresApproval: true,
+        handler: async (input: { task: string; max_iterations?: number }) => {
+          const { result, iterations, toolCalls } = await runLumenAgent(
+            input.task,
+            this.endpoint,
+            this.model,
+            input.max_iterations || 10,
+          );
+          return { result, iterations, toolCalls };
+        },
+      },
+
+      // ── Git shortcuts ─────────────────────────────────────────────────
+      {
+        name: 'lumen_git_commit',
+        description: 'Stage all changes and commit with a message using Lumen.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            message: { type: 'string', description: 'Commit message' },
+            working_dir: { type: 'string', description: 'Repo directory (default: cwd)' },
+          },
+          required: ['message'],
+        },
+        handler: async (input: { message: string; working_dir?: string }) => {
+          const cwd = input.working_dir || process.cwd();
+          const { result, toolCalls } = await runLumenAgent(
+            `Stage all changes and commit with message: "${input.message}". Working directory: ${cwd}`,
+            this.endpoint,
+            this.model,
+          );
+          return { result, toolCalls };
+        },
+      },
+
+      {
+        name: 'lumen_git_push',
+        description: 'Push current branch to origin using Lumen.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            working_dir: { type: 'string', description: 'Repo directory (default: cwd)' },
+          },
+          required: [],
+        },
+        handler: async (input: { working_dir?: string }) => {
+          const cwd = input.working_dir || process.cwd();
+          const { result, toolCalls } = await runLumenAgent(
+            `Push the current branch to origin. Working directory: ${cwd}`,
+            this.endpoint,
+            this.model,
+          );
+          return { result, toolCalls };
+        },
+      },
+
+      {
+        name: 'lumen_git_status',
+        description: 'Get git status of a repository using Lumen.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            working_dir: { type: 'string', description: 'Repo directory (default: cwd)' },
+          },
+          required: [],
+        },
+        handler: async (input: { working_dir?: string }) => {
+          const cwd = input.working_dir || process.cwd();
+          const { result, toolCalls } = await runLumenAgent(
+            `Show git status and a brief summary of changes. Working directory: ${cwd}`,
+            this.endpoint,
+            this.model,
+          );
+          return { result, toolCalls };
+        },
+      },
+
+      // ── Code tools ────────────────────────────────────────────────────
+      {
+        name: 'lumen_fix_bug',
+        description: 'Ask Lumen to investigate and fix a bug in your codebase.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            description: { type: 'string', description: 'Bug description or error message' },
+            working_dir: { type: 'string', description: 'Project directory (default: cwd)' },
+          },
+          required: ['description'],
+        },
+        requiresApproval: true,
+        handler: async (input: { description: string; working_dir?: string }) => {
+          const cwd = input.working_dir || process.cwd();
+          const { result, toolCalls } = await runLumenAgent(
+            `Investigate and fix this bug: ${input.description}\nWorking directory: ${cwd}`,
+            this.endpoint,
+            this.model,
+          );
+          return { result, toolCalls };
+        },
+      },
+
+      {
+        name: 'lumen_write_file',
+        description: 'Ask Lumen to write or generate a file with given requirements.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            path: { type: 'string', description: 'File path to create/overwrite' },
+            requirements: { type: 'string', description: 'What the file should contain or do' },
+          },
+          required: ['path', 'requirements'],
+        },
+        requiresApproval: true,
+        handler: async (input: { path: string; requirements: string }) => {
+          const { result, toolCalls } = await runLumenAgent(
+            `Write a file at "${input.path}" with these requirements: ${input.requirements}`,
+            this.endpoint,
+            this.model,
+          );
+          return { result, toolCalls };
+        },
+      },
+
+      // ── Shell tool ────────────────────────────────────────────────────
+      {
+        name: 'lumen_shell',
+        description: 'Ask Lumen to run a shell task and interpret the results.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            task: { type: 'string', description: 'What you want done in the terminal' },
+            working_dir: { type: 'string', description: 'Working directory (default: cwd)' },
+          },
+          required: ['task'],
+        },
+        requiresApproval: true,
+        handler: async (input: { task: string; working_dir?: string }) => {
+          const cwd = input.working_dir || process.cwd();
+          const { result, toolCalls } = await runLumenAgent(
+            `${input.task}\nWorking directory: ${cwd}`,
+            this.endpoint,
+            this.model,
+          );
+          return { result, toolCalls };
+        },
+      },
+
+      // ── Status / ping ─────────────────────────────────────────────────
+      {
+        name: 'lumen_ping',
+        description: 'Check if Lumen is running and available.',
+        inputSchema: { type: 'object', properties: {}, required: [] },
+        handler: async () => {
+          const ok = await this.ping();
+          if (!ok) return { status: 'offline', endpoint: this.endpoint };
+          const models = await this.listModels();
+          const hasLumen = models.some((m) => m.includes(this.model));
+          return {
+            status: hasLumen ? 'ready' : 'ollama_running_but_model_missing',
+            model: this.model,
+            endpoint: this.endpoint,
+            available_models: models,
+            hint: hasLumen ? null : `Run: ollama pull thealxlabs/lumen`,
+          };
+        },
+      },
+    ];
+  }
+}

package/src/plugins/builtin/memory.ts

@@ -0,0 +1,200 @@
+/**
+ * Memory Plugin
+ *
+ * Lightning-fast, leak-proof long-term memory using native SQLite.
+ * Uses simple text search (LIKE) to completely avoid RAM bloating and context leaks.
+ */
+
+import crypto from 'crypto';
+import { Plugin, PluginTool } from '../manager.js';
+import { Conductor } from '../../core/conductor.js';
+
+export type MemoryCategory = 'preference' | 'fact' | 'decision' | 'entity' | 'other';
+
+const _DEFAULT_CAPTURE_MAX_CHARS = 500;
+
+function detectCategory(text: string): MemoryCategory {
+  const t = text.toLowerCase();
+  if (/prefer|like|love|hate|want/i.test(t)) return 'preference';
+  if (/decided|will use|budeme/i.test(t)) return 'decision';
+  if (/\+\d{10,}|@[\w.-]+\.\w+|is called|jmenuje se/i.test(t)) return 'entity';
+  if (/\b(is|are|has|have|je|má|jsou)\b/i.test(t)) return 'fact';
+  return 'other';
+}
+
+function looksLikePromptInjection(text: string): boolean {
+  const normalized = text.replace(/\s+/g, ' ').trim();
+  const patterns = [
+    /ignore (all|any|previous|above|prior) instructions/i,
+    /do not follow (the )?(system|developer)/i,
+    /system prompt/i,
+  ];
+  return patterns.some((p) => p.test(normalized));
+}
+
+export class MemoryPlugin implements Plugin {
+  name = 'memory';
+  description = 'Long-term memory — store and recall important facts across conversations';
+  version = '2.0.0';
+
+  private conductor!: Conductor;
+  private currentUserId: string = 'global';
+
+  async initialize(conductor: Conductor): Promise<void> {
+    this.conductor = conductor;
+  }
+
+  /** Called by AIManager at the start of each conversation to scope queries correctly. */
+  setUserId(userId: string): void {
+    this.currentUserId = userId || 'global';
+  }
+
+  isConfigured(): boolean {
+    return true;
+  }
+
+  getTools(): PluginTool[] {
+    return [
+      {
+        name: 'memory_recall',
+        description: 'Search long-term memory for relevant facts, preferences, or decisions.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            query: { type: 'string', description: 'What to search for' },
+            limit: { type: 'number', description: 'Max results (default: 5)' },
+            category: { type: 'string', description: 'Optional category filter' },
+          },
+          required: ['query'],
+        },
+        handler: async ({ query, limit = 5, category }: any) => {
+          const db = this.conductor.getDatabase();
+          const results = await db.searchCoreMemory('global', query, limit, category);
+
+          if (results.length === 0) return { found: 0, memories: [] };
+
+          return {
+            found: results.length,
+            memories: results.map((r) => ({
+              id: r.id,
+              text: r.text,
+              category: r.category,
+              importance: r.importance,
+              createdAt: r.timestamp,
+            })),
+          };
+        },
+      },
+      {
+        name: 'memory_store',
+        description: 'Save important information to long-term memory.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            text: { type: 'string', description: 'Information to remember' },
+            importance: { type: 'number', description: 'Importance score 0–1 (default: 0.7)' },
+            category: { type: 'string', description: 'Category (auto-detected if omitted)' },
+            tags: { type: 'array', items: { type: 'string' } },
+          },
+          required: ['text'],
+        },
+        handler: async ({ text, importance = 0.7, category, tags }: any) => {
+          if (looksLikePromptInjection(text)) {
+            return { error: 'Rejected: text looks like a prompt injection attempt.' };
+          }
+
+          const detectedCategory: MemoryCategory = category ?? detectCategory(text);
+          const db = this.conductor.getDatabase();
+
+          const entry = {
+            id: crypto.randomUUID(),
+            userId: 'global',
+            text,
+            category: detectedCategory,
+            importance: Math.max(0, Math.min(1, importance)),
+            tags,
+          };
+
+          await db.addCoreMemory(entry);
+
+          return {
+            action: 'stored',
+            id: entry.id,
+            category: detectedCategory,
+            text: text.slice(0, 100),
+          };
+        },
+      },
+      {
+        name: 'memory_forget',
+        description: 'Delete a memory by ID.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            memoryId: { type: 'string', description: 'Exact memory UUID to delete' },
+          },
+          required: ['memoryId'],
+        },
+        handler: async ({ memoryId }: any) => {
+          const db = this.conductor.getDatabase();
+          await db.deleteCoreMemory(memoryId);
+          return { action: 'deleted', id: memoryId };
+        },
+      },
+      {
+        name: 'memory_list',
+        description: 'List all stored memories.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            category: { type: 'string', description: 'Filter by category' },
+            limit: { type: 'number', description: 'Max entries (default: 20)' },
+          },
+        },
+        handler: async ({ category, limit = 20 }: any) => {
+          const db = this.conductor.getDatabase();
+          const all = await db.listCoreMemory('global', category, limit);
+
+          return {
+            total: all.length,
+            memories: all.map((e) => ({
+              id: e.id,
+              text: e.text.slice(0, 120),
+              category: e.category,
+              importance: e.importance,
+              createdAt: e.timestamp,
+            })),
+          };
+        },
+      },
+      {
+        name: 'search_past_conversations',
+        description: 'Search raw past chat logs and conversations without bloating the context window.',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            query: { type: 'string', description: 'What text to search for' },
+            limit: { type: 'number', description: 'Max messages to return (default: 10)' },
+          },
+          required: ['query'],
+        },
+        handler: async ({ query, limit = 10 }: any) => {
+          const db = this.conductor.getDatabase();
+          // Use the stored userId set by setUserId(). Falls back to 'global' if not set.
+          const results = await db.searchMessages(this.currentUserId, query, limit);
+
+          if (results.length === 0) return { found: 0, messages: [] };
+
+          return {
+            found: results.length,
+            messages: results.map((r) => ({
+              role: r.role,
+              content: r.content ? r.content.slice(0, 200) : '',
+              timestamp: r.timestamp,
+            })),
+          };
+        },
+      },
+    ];
+  }
+}