@castlemilk/omega 0.1.3

package/dist/cli.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+
+// ../../apps/cli/src/index.ts
+import { program as program2 } from "commander";
+
+// ../../apps/cli/src/commands/project.ts
+import { Command } from "commander";
+
+// ../../apps/cli/src/api.ts
+import { program } from "commander";
+function getApiUrl() {
+  const opts = program.opts();
+  return opts.api || "http://localhost:4000";
+}
+async function apiFetch(path2, init) {
+  const url = `${getApiUrl()}${path2}`;
+  const res = await fetch(url, init);
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(data.error || `HTTP ${res.status}`);
+  }
+  return data;
+}
+
+// ../../apps/cli/src/commands/project.ts
+var projectCmd = new Command("project").description("Manage projects");
+projectCmd.command("add").description("Add a project").requiredOption("--name <name>", "project name").requiredOption("--path <path>", "project directory path").option("--repoUrl <url>", "repository URL").option("--description <text>", "project description").action(async (opts) => {
+  const project = await apiFetch("/projects", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      name: opts.name,
+      path: opts.path,
+      repoUrl: opts.repoUrl,
+      description: opts.description
+    })
+  });
+  console.log(JSON.stringify(project, null, 2));
+});
+projectCmd.command("list").description("List projects").action(async () => {
+  const projects = await apiFetch("/projects");
+  console.log(JSON.stringify(projects, null, 2));
+});
+projectCmd.command("remove").description("Remove a project").argument("<id>", "project id").action(async (id) => {
+  await apiFetch(`/projects/${id}`, { method: "DELETE" });
+  console.log("Project removed.");
+});
+
+// ../../apps/cli/src/commands/task.ts
+import { Command as Command2 } from "commander";
+var taskCmd = new Command2("task").description("Manage tasks");
+taskCmd.command("create").description("Create a task").requiredOption("--project <id>", "project id").requiredOption("--title <title>", "task title").option("--description <text>", "task description").option("--complexity <level>", "simple | medium | complex", "simple").option("--tags <tags>", "comma-separated tags").action(async (opts) => {
+  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: opts.tags ? opts.tags.split(",").map((t) => t.trim()) : []
+    })
+  });
+  console.log(JSON.stringify(task, null, 2));
+});
+taskCmd.command("list").description("List tasks").option("--project <id>", "filter by project id").action(async (opts) => {
+  const query = opts.project ? `?projectId=${opts.project}` : "";
+  const tasks = await apiFetch(`/tasks${query}`);
+  console.log(JSON.stringify(tasks, null, 2));
+});
+taskCmd.command("run").description("Run a task through the router").argument("<id>", "task id").action(async (id) => {
+  const result = await apiFetch(`/tasks/${id}/run`, { method: "POST" });
+  console.log(JSON.stringify(result, null, 2));
+});
+
+// ../../apps/cli/src/commands/ui.ts
+import { Command as Command3 } from "commander";
+import { spawn } from "child_process";
+import open from "open";
+var uiCmd = new Command3("ui").description("Open the harness web UI").action(async () => {
+  const server = spawn("pnpm", ["--filter", "@omega/server", "dev"], {
+    stdio: "inherit",
+    shell: true
+  });
+  setTimeout(async () => {
+    await open("http://localhost:4000");
+  }, 2500);
+  server.on("exit", (code) => {
+    process.exit(code ?? 0);
+  });
+});
+
+// ../../apps/cli/src/commands/skill.ts
+import { Command as Command4 } from "commander";
+import path from "path";
+import { fileURLToPath } from "url";
+
+// ../skills/src/parse.ts
+import matter from "gray-matter";
+import YAML from "yaml";
+function parseSkill(md) {
+  const parsed = matter(md);
+  const frontmatter = YAML.parse(parsed.matter || "{}");
+  if (typeof frontmatter.name !== "string" || frontmatter.name.trim() === "") {
+    throw new Error('SKILL.md frontmatter must include a non-empty "name" string');
+  }
+  if (typeof frontmatter.description !== "string" || frontmatter.description.trim() === "") {
+    throw new Error('SKILL.md frontmatter must include a non-empty "description" string');
+  }
+  let args = [];
+  if ("args" in frontmatter) {
+    if (!Array.isArray(frontmatter.args)) {
+      throw new Error('SKILL.md frontmatter "args" must be an array');
+    }
+    args = frontmatter.args.map((entry, index) => {
+      if (typeof entry !== "object" || entry === null) {
+        throw new Error(`SKILL.md arg at index ${index} must be an object`);
+      }
+      const arg = entry;
+      if (typeof arg.name !== "string" || arg.name.trim() === "") {
+        throw new Error(`SKILL.md arg at index ${index} must have a non-empty "name"`);
+      }
+      if (typeof arg.type !== "string" || arg.type.trim() === "") {
+        throw new Error(`SKILL.md arg at index ${index} must have a non-empty "type"`);
+      }
+      return {
+        name: arg.name.trim(),
+        type: arg.type.trim(),
+        required: typeof arg.required === "boolean" ? arg.required : true,
+        description: typeof arg.description === "string" ? arg.description : void 0
+      };
+    });
+  }
+  return {
+    name: frontmatter.name.trim(),
+    description: frontmatter.description.trim(),
+    args,
+    instructions: parsed.content.trim()
+  };
+}
+
+// ../skills/src/generate.ts
+function toClassName(name) {
+  const normalized = name.replace(/[^a-zA-Z0-9]+/g, " ").trim().split(" ").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+  let className = normalized || "Skill";
+  if (/^[0-9]/.test(className)) {
+    className = `_${className}`;
+  }
+  return className;
+}
+function generateAdapter(manifest) {
+  const className = toClassName(manifest.name);
+  const instructionsLiteral = JSON.stringify(manifest.instructions);
+  const descriptionLiteral = JSON.stringify(manifest.description);
+  return `import type { Provider } from '@omega/core';
+
+export class ${className} {
+  constructor(private readonly provider: Provider) {}
+
+  async execute(args: Record<string, unknown>): Promise<string> {
+    const prompt = ${instructionsLiteral} + '\\n\\nArgs:\\n' + JSON.stringify(args, null, 2);
+    return this.provider.send(prompt, { system: ${descriptionLiteral} });
+  }
+}
+`;
+}
+
+// ../skills/src/register.ts
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+async function registerSkill(sourcePath, outputDir) {
+  const source = await readFile(sourcePath, "utf-8");
+  const manifest = parseSkill(source);
+  const generatedDir = join(outputDir, "generated");
+  await mkdir(generatedDir, { recursive: true });
+  const className = toClassName(manifest.name);
+  const fileName = `${className}.ts`;
+  const filePath = join(generatedDir, fileName);
+  await writeFile(filePath, generateAdapter(manifest), "utf-8");
+  const indexPath = join(generatedDir, "index.ts");
+  const exportLine = `export * from './${className}.js';
+`;
+  let indexContent = "";
+  try {
+    indexContent = await readFile(indexPath, "utf-8");
+  } catch {
+  }
+  if (!indexContent.includes(exportLine)) {
+    await writeFile(indexPath, indexContent + exportLine, "utf-8");
+  }
+  return manifest;
+}
+
+// ../../apps/cli/src/commands/skill.ts
+function getOutputDir() {
+  if (process.env.OMEGA_HARNESS_ROOT) {
+    return path.join(path.resolve(process.env.OMEGA_HARNESS_ROOT), "packages/skills/src");
+  }
+  try {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    return path.join(path.resolve(__dirname, "../../../.."), "packages/skills/src");
+  } catch {
+    return path.join(process.cwd(), "harness-skills");
+  }
+}
+var skillCmd = new Command4("skill").description("Manage skill artifacts");
+skillCmd.command("generate").description("Generate a harness adapter from a SKILL.md file").argument("<source>", "path to SKILL.md").action(async (source) => {
+  const outputDir = getOutputDir();
+  const manifest = await registerSkill(path.resolve(source), outputDir);
+  console.log(`Generated adapter for skill: ${manifest.name}`);
+  console.log(`Output directory: ${path.join(outputDir, "generated")}`);
+});
+
+// ../../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);
+program2.addCommand(taskCmd);
+program2.addCommand(uiCmd);
+program2.addCommand(skillCmd);
+program2.parse();

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@castlemilk/omega",
+  "version": "0.1.3",
+  "description": "Omega Harness CLI - installable via npx",
+  "type": "module",
+  "main": "./dist/cli.js",
+  "bin": {
+    "harness": "./dist/cli.js",
+    "omega-harness": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "commander": "^12.1.0",
+    "open": "^10.1.0",
+    "gray-matter": "^4.0.3",
+    "yaml": "^2.4.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.23.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/castlemilk/harness.git"
+  },
+  "scripts": {
+    "build": "esbuild ../../apps/cli/src/index.ts --bundle --platform=node --format=esm --outfile=dist/cli.js --external:commander --external:open --external:gray-matter --external:yaml --alias:@omega/core=../../packages/core/src/index.ts --alias:@omega/skills=../../packages/skills/src/index.ts"
+  }
+}