@castlemilk/omega 0.3.0 → 0.4.0

package/dist/cli.js

@@ -638,6 +638,75 @@ skillCmd.command("generate").description("Generate a harness adapter from a SKIL
   console.log(`Output directory: ${path3.join(outputDir, "generated")}`);
 });
 
+// ../../apps/cli/src/commands/agent.ts
+import { Command as Command7 } from "commander";
+var agentCmd = new Command7("agent").description("Autonomous agent loop");
+agentCmd.command("run").description("Run a single agent task").requiredOption("--project <id>", "project id").requiredOption("--title <title>", "task title").option("--description <text>", "task description").option("--complexity <level>", "simple | medium | complex", "complex").option("--auto-publish", "publish if validation passes", false).action(
+  async (opts) => {
+    const tags = ["agent"];
+    if (opts.autoPublish) tags.push("publish");
+    const task = await apiFetch("/tasks", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        projectId: opts.project,
+        title: opts.title,
+        description: opts.description,
+        complexity: opts.complexity,
+        tags
+      })
+    });
+    console.log(JSON.stringify(task, null, 2));
+    const result = await apiFetch(`/tasks/${task.id}/run`, { method: "POST" });
+    console.log(JSON.stringify(result, null, 2));
+  }
+);
+agentCmd.command("loop").description("Continuously run agent tasks").requiredOption("--project <id>", "project id").option("--interval <min>", "minutes between loops", "30").option("--auto-publish", "publish if validation passes", false).option("--prompt <text>", "overriding self-improvement prompt").action(
+  async (opts) => {
+    const intervalMin = parseInt(opts.interval, 10);
+    const intervalMs = intervalMin * 60 * 1e3;
+    const runOnce = async () => {
+      const title = opts.prompt ?? "Improve the Omega harness: fix a TODO, add a test, refactor a function, or improve documentation";
+      const tags = ["agent", "self-improve"];
+      if (opts.autoPublish) tags.push("publish");
+      const task = await apiFetch("/tasks", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          projectId: opts.project,
+          title,
+          description: "Use the available tools to make a small, verifiable improvement to the codebase. Run lint and tests. Finish with a summary.",
+          complexity: "complex",
+          tags
+        })
+      });
+      console.log(`Created task ${task.id}`);
+      const result = await apiFetch(`/tasks/${task.id}/run`, { method: "POST" });
+      console.log(JSON.stringify(result, null, 2));
+      return result;
+    };
+    await runOnce();
+    if (intervalMs > 0) {
+      console.log(`Looping every ${opts.interval} minute(s). Press Ctrl+C to stop.`);
+      setInterval(() => {
+        void runOnce();
+      }, intervalMs);
+    }
+  }
+);
+agentCmd.command("steps").description("Show steps for a task").argument("<id>", "task id").action(async (id) => {
+  const steps = await apiFetch(`/tasks/${id}/steps`);
+  console.log(JSON.stringify(steps, null, 2));
+});
+agentCmd.command("traces").description("Show traces for a task").argument("<id>", "task id").action(async (id) => {
+  const traces = await apiFetch(`/tasks/${id}/traces`);
+  console.log(JSON.stringify(traces, null, 2));
+});
+agentCmd.command("diffs").description("Show diffs for a task").argument("<id>", "task id").action(async (id) => {
+  const diffs = await apiFetch(`/tasks/${id}/diffs`);
+  console.log(JSON.stringify(diffs, null, 2));
+});
+
 // ../../apps/cli/src/index.ts
 program2.name("harness").description("Omega harness CLI").version("0.1.0").option("--api <url>", "API base URL", "http://localhost:4000");
 program2.addCommand(projectCmd);
@@ -645,4 +714,5 @@ program2.addCommand(taskCmd);
 program2.addCommand(uiCmd);
 program2.addCommand(consoleCmd);
 program2.addCommand(skillCmd);
+program2.addCommand(agentCmd);
 program2.parse();

package/dist/server.js

@@ -3,7 +3,6 @@
 // src/server.ts
 import express from "express";
 import cors from "cors";
-import path from "path";
 import { fileURLToPath } from "url";
 import { z } from "zod";
 import * as grpc from "@grpc/grpc-js";
@@ -49,6 +48,48 @@ var OpenAIProvider = class {
     const data = await res.json();
     return data.choices?.[0]?.message?.content ?? "";
   }
+  async sendWithTools(prompt, tools, opts) {
+    const res = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...this.authHeaders()
+      },
+      body: JSON.stringify({
+        model: opts?.model ?? this.config.defaultModel,
+        messages: [
+          ...opts?.system ? [{ role: "system", content: opts.system }] : [],
+          { role: "user", content: prompt }
+        ],
+        tools: tools.map((t) => ({
+          type: "function",
+          function: { name: t.name, description: t.description, parameters: t.parameters }
+        })),
+        temperature: opts?.temperature
+      })
+    });
+    if (!res.ok) {
+      throw new Error(`OpenAI tools request failed: ${res.status.toString()} ${res.statusText}`);
+    }
+    const data = await res.json();
+    const message = data.choices?.[0]?.message;
+    const toolCalls = message?.tool_calls;
+    if (toolCalls && toolCalls.length > 0) {
+      const normalized = toolCalls.map((tc) => ({
+        id: tc.id ?? "",
+        name: tc.function?.name ?? "",
+        arguments: (() => {
+          try {
+            return JSON.parse(tc.function?.arguments ?? "{}");
+          } catch {
+            return {};
+          }
+        })()
+      })).filter((tc) => tc.id && tc.name);
+      return JSON.stringify({ tool_calls: normalized });
+    }
+    return message?.content ?? "";
+  }
   authHeaders() {
     return this.config.apiKey ? { Authorization: `Bearer ${this.config.apiKey}` } : {};
   }
@@ -189,7 +230,7 @@ var KimiProvider = class extends OpenAIProvider {
   constructor(config) {
     super({
       ...config,
-      baseUrl: config.baseUrl ?? "https://api.moonshot.ai/v1"
+      baseUrl: config.baseUrl ?? "https://api.moonshot.cn/v1"
     });
     this.config = config;
   }
@@ -278,6 +319,11 @@ function selectProvider(configs, rules2, task) {
 }
 
 // src/server.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = path.dirname(__filename);
 function asyncHandler(fn) {
@@ -498,10 +544,145 @@ function parseGrpcRequest(req) {
 function isValidComplexity(value) {
   return ["simple", "medium", "complex"].includes(value);
 }
+var AGENT_TOOLS = [
+  {
+    name: "read_file",
+    description: "Read a file relative to project root.",
+    parameters: { type: "object", properties: { path: { type: "string" } }, required: ["path"] }
+  },
+  {
+    name: "write_file",
+    description: "Write content to a file relative to project root.",
+    parameters: {
+      type: "object",
+      properties: { path: { type: "string" }, content: { type: "string" } },
+      required: ["path", "content"]
+    }
+  },
+  {
+    name: "run_command",
+    description: "Run a shell command in the project root.",
+    parameters: { type: "object", properties: { command: { type: "string" } }, required: ["command"] }
+  },
+  {
+    name: "finish",
+    description: "Mark the task complete.",
+    parameters: {
+      type: "object",
+      properties: { summary: { type: "string" }, success: { type: "boolean" } },
+      required: ["summary", "success"]
+    }
+  }
+];
+var AGENT_SYSTEM_PROMPT = `You are Omega, an autonomous software engineering agent. Respond with JSON: {"tool_calls":[{"id":"1","name":"tool_name","arguments":{}}]}. Available tools: read_file, write_file, run_command, finish. Work in small steps, run tests, and finish when done.`;
+function argString(value) {
+  if (value === void 0 || value === null) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return value.toString();
+  return JSON.stringify(value);
+}
+async function executeBundleTool(projectPath, name, args) {
+  const target = (file) => {
+    const resolved = path.resolve(projectPath, file);
+    if (!resolved.startsWith(path.resolve(projectPath))) throw new Error("Path traversal blocked");
+    return resolved;
+  };
+  try {
+    switch (name) {
+      case "read_file": {
+        const content = await fs.readFile(target(argString(args.path)), "utf-8");
+        return { success: true, output: content };
+      }
+      case "write_file": {
+        const p = target(argString(args.path));
+        await fs.mkdir(path.dirname(p), { recursive: true });
+        await fs.writeFile(p, argString(args.content), "utf-8");
+        return { success: true, output: `Wrote ${argString(args.path)}` };
+      }
+      case "run_command": {
+        const [cmd, ...cmdArgs] = argString(args.command).split(" ");
+        const { stdout, stderr } = await execFileAsync(cmd, cmdArgs, {
+          cwd: projectPath,
+          timeout: 12e4,
+          shell: false
+        });
+        return { success: true, output: stdout + stderr };
+      }
+      default:
+        return { success: false, output: `Unknown tool: ${name}` };
+    }
+  } catch (err) {
+    return { success: false, output: err instanceof Error ? err.message : String(err) };
+  }
+}
+function parseBundleToolCalls(raw) {
+  try {
+    const cleaned = raw.trim().replace(/^```[a-z]*\n?/, "").replace(/\n?```$/, "");
+    const parsed = JSON.parse(cleaned);
+    if (!Array.isArray(parsed.tool_calls)) return [];
+    const calls = parsed.tool_calls;
+    return calls.filter((t) => Boolean(t.id && t.name)).map((t) => ({ id: t.id, name: t.name, arguments: t.arguments }));
+  } catch {
+    return [];
+  }
+}
+async function executeAgentTask(task) {
+  task.status = "in_progress";
+  task.error = void 0;
+  task.result = void 0;
+  const project = projects.find((p) => p.id === task.projectId);
+  if (!project) {
+    task.status = "failed";
+    task.error = "Project not found for agent task";
+    return;
+  }
+  const selection = selectProvider(providerConfigs, rules, task);
+  if (!selection) {
+    task.status = "failed";
+    task.error = "No provider available for this task";
+    return;
+  }
+  try {
+    const provider = createProvider(selection.provider);
+    const prompt = [task.title, task.description].filter(Boolean).join("\n\n");
+    let response;
+    if ("sendWithTools" in provider && typeof provider.sendWithTools === "function") {
+      response = await provider.sendWithTools(prompt, AGENT_TOOLS, {
+        system: AGENT_SYSTEM_PROMPT,
+        model: selection.model
+      });
+    } else {
+      response = await provider.send(prompt, { system: AGENT_SYSTEM_PROMPT, model: selection.model });
+    }
+    const calls = parseBundleToolCalls(response);
+    const results = [];
+    for (const call of calls) {
+      if (call.name === "finish") {
+        task.status = call.arguments.success ? "done" : "failed";
+        const summaryArg = call.arguments.summary;
+        task.result = typeof summaryArg === "string" ? summaryArg : "";
+        break;
+      }
+      const result = await executeBundleTool(project.path, call.name, call.arguments);
+      results.push(`${call.name}: ${result.output}`);
+    }
+    if (calls.length > 0 && calls.every((c) => c.name !== "finish")) {
+      task.status = "done";
+      task.result = results.join("\n");
+    }
+    task.assignedModel = { provider: selection.provider.name, model: selection.model };
+  } catch (err) {
+    task.status = "failed";
+    task.error = err instanceof Error ? err.message : String(err);
+  }
+}
 async function executeTask(task) {
   task.status = "in_progress";
   task.error = void 0;
   task.result = void 0;
+  if (task.tags.includes("agent") || task.tags.includes("self-improve")) {
+    return executeAgentTask(task);
+  }
   const selection = selectProvider(providerConfigs, rules, task);
   if (!selection) {
     task.status = "failed";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@castlemilk/omega",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Omega Harness CLI - installable via npx",
   "type": "module",
   "main": "./dist/cli.js",
@@ -30,8 +30,8 @@
     "@types/node": "^20.14.0",
     "esbuild": "^0.23.0",
     "@omega/core": "0.1.0",
-    "@omega/providers": "0.1.0",
-    "@omega/router": "0.1.0"
+    "@omega/router": "0.1.0",
+    "@omega/providers": "0.1.0"
   },
   "publishConfig": {
     "access": "public"