@hilbras/omninode 0.4.0 → 0.5.0

package/README.md

@@ -18,7 +18,7 @@ existing intelligence; it does not try to become another model.
 
 ## Status
 
-**v0.4.0 — Phase 3: CLI Agent System** (see [docs/DEVELOPMENT_PLAN.md](docs/DEVELOPMENT_PLAN.md)
+**v0.5.0 — Phase 4: Roles & Tasks** (see [docs/DEVELOPMENT_PLAN.md](docs/DEVELOPMENT_PLAN.md)
 for the full plan and roadmap).
 
 What exists today:
@@ -44,6 +44,15 @@ What exists today:
     `TASK`/`ROLE`/`CONTEXT`/`INSTRUCTION` envelopes in, `REPORT`/`COMPLETION`/
     `ERROR` messages out, parsed into structured reports)
   - Agent factory and registry (`createAgent`, `AgentRegistry`)
+- **Roles & tasks** (`src/roles/`, `src/tasks/`):
+  - `RoleRegistry` with assignment validation — a task can only reference roles
+    and agents that actually exist
+  - Task lifecycle (created → queued → running → completed/failed/cancelled)
+    with transition enforcement
+  - `TaskEngine` runs tasks through their assigned agent, records structured
+    results (summary, reports, errors, timestamps)
+  - `TaskStore` interface with a local-first JSON implementation in
+    `.omninode/tasks.json` (atomic writes; swap in any backend)
 - Typed error hierarchy (`src/errors/`)
 - Leveled logger with pluggable sink (`src/logger/`)
 - Configuration system: `omninode.yaml` with `${ENV_VAR}` expansion and strict
@@ -93,6 +102,15 @@ omninode agent add --name opencode --command opencode --input-mode arg
 omninode agent test opencode     # sends a trivial task over the real adapter
 ```
 
+Create, run and track tasks (the `Project → Task → Role → Agent` chain):
+
+```bash
+omninode task create "audit the auth module" --role security-reviewer --agent opencode
+omninode task run task-xxxxxx
+omninode task status task-xxxxxx
+omninode task list
+```
+
 See [omninode.yaml.example](omninode.yaml.example) for a full configuration.
 
 ### Configuration
@@ -125,8 +143,8 @@ Phases 0–11 are laid out in [docs/DEVELOPMENT_PLAN.md](docs/DEVELOPMENT_PLAN.m
 | v0.1.0 | Foundation |
 | v0.2.0 | Provider System |
 | v0.3.0 | OmniHilbras Integration (optional, like every provider) |
-| **v0.4.0** | **CLI Agent System (current)** |
-| v0.5.0 | Roles & Tasks |
+| v0.4.0 | Agent System |
+| **v0.5.0** | **Roles & Tasks (current)** |
 | v0.6.0 | Pipeline Engine |
 | v0.7.0 | Multi-AI Reports |
 | v0.8.0 | Remembera (optional memory integration) |

package/dist/cli/index.js

@@ -34,6 +34,11 @@ var AgentError = class extends OmniNodeError {
     super(code, message, options);
   }
 };
+var TaskError = class extends OmniNodeError {
+  constructor(code, message, options = {}) {
+    super(code, message, options);
+  }
+};
 var ProtocolError = class extends OmniNodeError {
   constructor(message, options = {}) {
     super("PROTOCOL_VIOLATION", message, options);
@@ -1061,6 +1066,20 @@ function firstLine(text, maxLength = 200) {
   return line.length > maxLength ? `${line.slice(0, maxLength)}\u2026` : line;
 }
 
+// src/agents/registry.ts
+var AgentRegistry = class {
+  agents = /* @__PURE__ */ new Map();
+  register(agent) {
+    this.agents.set(agent.info.name, agent);
+  }
+  get(name) {
+    return this.agents.get(name);
+  }
+  list() {
+    return [...this.agents.values()].sort((a, b) => a.info.name.localeCompare(b.info.name));
+  }
+};
+
 // src/agents/factory.ts
 function createAgent(config) {
   if (config.integration === "process") {
@@ -1074,6 +1093,19 @@ function createAgent(config) {
   }
   throw new OmniNodeError("NOT_IMPLEMENTED", `Agent integration "${config.integration}" has no adapter yet.`);
 }
+function buildAgentRegistry(config, log = logger) {
+  const registry = new AgentRegistry();
+  for (const agentConfig of config.project.agents) {
+    try {
+      registry.register(createAgent(agentConfig));
+    } catch (error) {
+      log.warn(
+        `Skipping agent "${agentConfig.name}": ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return registry;
+}
 
 // src/cli/commands/agents.ts
 var collectArgs = (value, previous) => [...previous, value];
@@ -1179,19 +1211,305 @@ function registerRoleCommands(program) {
   });
 }
 
+// src/tasks/store.ts
+import { mkdir, readFile, rename, writeFile } from "fs/promises";
+import { dirname } from "path";
+var FileTaskStore = class {
+  filePath;
+  constructor(directory = `${process.cwd()}/.omninode`) {
+    this.filePath = `${directory}/tasks.json`;
+  }
+  async save(task) {
+    const tasks = await this.load();
+    const index = tasks.findIndex((t) => t.id === task.id);
+    if (index >= 0) tasks[index] = task;
+    else tasks.push(task);
+    await this.write(tasks);
+  }
+  async get(id) {
+    const tasks = await this.load();
+    return tasks.find((t) => t.id === id);
+  }
+  async list(filter = {}) {
+    const tasks = await this.load();
+    return tasks.filter((task) => filter.status ? task.status === filter.status : true).filter((task) => filter.project ? task.project === filter.project : true).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  }
+  async load() {
+    try {
+      const raw = await readFile(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+  async write(tasks) {
+    const tmp = `${this.filePath}.tmp`;
+    await mkdir(dirname(this.filePath), { recursive: true });
+    await writeFile(tmp, `${JSON.stringify(tasks, null, 2)}
+`, "utf8");
+    await rename(tmp, this.filePath);
+  }
+};
+
+// src/tasks/engine.ts
+import { randomBytes } from "crypto";
+var ALLOWED_TRANSITIONS = {
+  created: ["queued", "running", "cancelled"],
+  queued: ["running", "cancelled"],
+  running: ["completed", "failed", "cancelled"],
+  waiting: ["running", "cancelled"],
+  completed: [],
+  failed: [],
+  cancelled: []
+};
+var TaskEngine = class {
+  constructor(options) {
+    this.options = options;
+    this.log = (options.log ?? logger).child({ component: "tasks" });
+  }
+  options;
+  log;
+  get store() {
+    return this.options.store;
+  }
+  async create(input) {
+    if (!input.objective || input.objective.trim().length === 0) {
+      throw new TaskError("TASK_INVALID", "Task objective must not be empty.");
+    }
+    if (input.role && !this.options.roles.get(input.role)) {
+      throw new TaskError(
+        "TASK_INVALID",
+        `Role "${input.role}" is not defined. Add it under project.roles in omninode.yaml.`
+      );
+    }
+    if (input.agent && !this.options.agents.get(input.agent)) {
+      throw new TaskError(
+        "TASK_INVALID",
+        `Agent "${input.agent}" is not registered. Add it with \`omninode agent add\`.`
+      );
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const task = {
+      id: generateTaskId(),
+      objective: input.objective.trim(),
+      status: "created",
+      createdAt: now,
+      updatedAt: now,
+      ...input.project !== void 0 ? { project: input.project } : {},
+      ...input.role !== void 0 ? { role: input.role } : {},
+      ...input.agent !== void 0 ? { agent: input.agent } : {},
+      ...input.context !== void 0 ? { context: input.context } : {}
+    };
+    await this.options.store.save(task);
+    this.log.info(`Created task ${task.id}.`);
+    return task;
+  }
+  async queue(id) {
+    const task = await this.mustGet(id);
+    return this.transition(task, "queued");
+  }
+  /** Runs the task through its assigned agent and records the result. */
+  async run(id) {
+    const task = await this.mustGet(id);
+    if (task.status !== "created" && task.status !== "queued") {
+      throw new TaskError("TASK_INVALID", `Task ${id} is "${task.status}" and cannot be run.`);
+    }
+    if (!task.agent) {
+      throw new TaskError("TASK_INVALID", `Task ${id} has no agent assigned. Re-create it with --agent.`);
+    }
+    const agent = this.options.agents.get(task.agent);
+    if (!agent) {
+      throw new TaskError("TASK_INVALID", `Agent "${task.agent}" is not registered anymore.`);
+    }
+    const role = task.role ? this.options.roles.get(task.role) : void 0;
+    const running = await this.transition(task, "running");
+    this.log.info(`Running task ${task.id} on agent "${task.agent}".`);
+    let output;
+    try {
+      output = await agent.run({
+        taskId: running.id,
+        objective: running.objective,
+        ...role ? { role } : {},
+        ...running.context?.background ? { context: running.context.background } : {}
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.log.error(`Task ${task.id} failed: ${message}`);
+      return this.transition(running, "failed", {
+        result: { error: message, finishedAt: (/* @__PURE__ */ new Date()).toISOString() }
+      });
+    }
+    const result = {
+      ...output.summary !== void 0 ? { summary: output.summary } : {},
+      ...output.reports !== void 0 && output.reports.length > 0 ? { reports: output.reports } : {},
+      ...output.error !== void 0 ? { error: output.error } : {},
+      finishedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const finalStatus = output.status === "completed" ? "completed" : "failed";
+    this.log.info(`Task ${task.id} finished: ${finalStatus}.`);
+    return this.transition(running, finalStatus, { result });
+  }
+  async cancel(id) {
+    const task = await this.mustGet(id);
+    if (!ALLOWED_TRANSITIONS[task.status].includes("cancelled")) {
+      throw new TaskError("TASK_INVALID", `Task ${id} is "${task.status}" and cannot be cancelled.`);
+    }
+    if (task.agent) {
+      const agent = this.options.agents.get(task.agent);
+      await agent?.cancel?.(task.id);
+    }
+    return this.transition(task, "cancelled");
+  }
+  async get(id) {
+    return this.options.store.get(id);
+  }
+  async list(filter) {
+    return this.options.store.list(filter);
+  }
+  async mustGet(id) {
+    const task = await this.options.store.get(id);
+    if (!task) {
+      throw new TaskError("TASK_NOT_FOUND", `Task "${id}" does not exist in this project's task store.`);
+    }
+    return task;
+  }
+  async transition(task, to, extra = {}) {
+    const allowed = ALLOWED_TRANSITIONS[task.status] ?? [];
+    if (!allowed.includes(to)) {
+      throw new TaskError("TASK_INVALID", `Task ${task.id} cannot move from "${task.status}" to "${to}".`);
+    }
+    const updated = {
+      ...task,
+      status: to,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...extra.result !== void 0 ? { result: { ...task.result, ...extra.result } } : {}
+    };
+    await this.options.store.save(updated);
+    return updated;
+  }
+};
+function generateTaskId() {
+  return `task-${Date.now().toString(36)}-${randomBytes(3).toString("hex")}`;
+}
+
+// src/roles/index.ts
+var RoleRegistry = class {
+  roles = /* @__PURE__ */ new Map();
+  register(role) {
+    this.roles.set(role.id, role);
+  }
+  registerAll(roles) {
+    for (const role of roles) this.register(role);
+  }
+  get(id) {
+    return this.roles.get(id);
+  }
+  list() {
+    return [...this.roles.values()].sort((a, b) => a.id.localeCompare(b.id));
+  }
+};
+function buildRoleRegistry(config) {
+  const registry = new RoleRegistry();
+  registry.registerAll(config.project.roles);
+  return registry;
+}
+
+// src/tasks/engine-factory.ts
+function createTaskEngine(config, log = logger, directory) {
+  return new TaskEngine({
+    agents: buildAgentRegistry(config, log),
+    roles: buildRoleRegistry(config),
+    store: new FileTaskStore(directory),
+    log
+  });
+}
+
 // src/cli/commands/tasks.ts
+var collectFiles = (value, previous) => [...previous, value];
 function registerTaskCommands(program) {
-  const task = program.command("task").description("Create, run and inspect tasks (Phase 4+).");
-  task.command("create").description("Create a task (planned for Phase 4 \u2014 Roles & Tasks).").action(() => {
-    throw notImplemented("omninode task create", "Phase 4 (Roles & Tasks)");
+  const task = program.command("task").description("Create, run and inspect tasks (\xA713).");
+  task.command("create <objective>").description("Create a task. Assign a role and/or agent; run it with `omninode task run`.").option("-r, --role <roleId>", "Role id from project.roles (validated at creation).").option("-a, --agent <name>", "Agent name from project.agents (validated at creation).").option("-f, --file <path>", "File or glob relevant to the task (repeatable).", collectFiles).action(async (objective, options) => {
+    const config = loadConfig();
+    const engine = createTaskEngine(config);
+    const created = await engine.create({
+      objective,
+      project: config.project.name,
+      ...options.role !== void 0 ? { role: options.role } : {},
+      ...options.agent !== void 0 ? { agent: options.agent } : {},
+      ...options.file !== void 0 && options.file.length > 0 ? { context: { files: options.file } } : {}
+    });
+    console.log(`Created task ${created.id} (${created.status})`);
+    console.log(`  objective: ${created.objective}`);
+    if (created.role) console.log(`  role:      ${created.role}`);
+    if (created.agent) console.log(`  agent:     ${created.agent}`);
+    if (created.context?.files) console.log(`  files:     ${created.context.files.join(", ")}`);
+    console.log(`Run \`omninode task run ${created.id}\` to execute it.`);
+  });
+  task.command("run <task-id>").description("Run a task through its assigned agent.").action(async (taskId) => {
+    const config = loadConfig();
+    const engine = createTaskEngine(config);
+    console.log(`Running task ${taskId}...`);
+    const finished = await engine.run(taskId);
+    printOutcome(finished);
+    if (finished.status !== "completed") process.exitCode = 1;
+  });
+  task.command("status <task-id>").description("Show task details and current status.").action(async (taskId) => {
+    const config = loadConfig();
+    const engine = createTaskEngine(config);
+    const found = await engine.get(taskId);
+    if (!found) {
+      throw new TaskError(
+        "TASK_NOT_FOUND",
+        `Task "${taskId}" does not exist in this project's task store.`
+      );
+    }
+    printOutcome(found, { verbose: true });
   });
-  task.command("run <objective>").description("Run a task or pipeline (planned for Phase 5 \u2014 Pipeline Engine).").action(() => {
-    throw notImplemented("omninode task run", "Phase 5 (Pipeline Engine)");
+  task.command("list").description("List tasks in the project's task store.").option("-s, --status <status>", "Filter by status (created, queued, running, completed, failed, cancelled).").action(async (options) => {
+    const config = loadConfig();
+    const engine = createTaskEngine(config);
+    const tasks = await engine.list(
+      options.status !== void 0 ? { status: options.status } : {}
+    );
+    if (tasks.length === 0) {
+      console.log("No tasks found. Create one with `omninode task create`.");
+      return;
+    }
+    for (const t of tasks) {
+      console.log(`${t.id}  ${t.status.padEnd(10)} ${truncate(t.objective, 60)}`);
+    }
   });
-  task.command("status <task-id>").description("Show task status (planned for Phase 4 \u2014 Roles & Tasks).").action(() => {
-    throw notImplemented("omninode task status", "Phase 4 (Roles & Tasks)");
+  task.command("cancel <task-id>").description("Cancel a task that has not finished yet.").action(async (taskId) => {
+    const config = loadConfig();
+    const engine = createTaskEngine(config);
+    const cancelled = await engine.cancel(taskId);
+    console.log(`Task ${cancelled.id} is now "${cancelled.status}".`);
   });
 }
+function printOutcome(task, options = {}) {
+  console.log(`  id:      ${task.id}`);
+  console.log(`  status:  ${task.status}`);
+  console.log(`  created: ${task.createdAt}`);
+  if (options.verbose) {
+    console.log(`  project: ${task.project ?? "(none)"}`);
+    if (task.role) console.log(`  role:    ${task.role}`);
+    if (task.agent) console.log(`  agent:   ${task.agent}`);
+    if (task.context?.files) console.log(`  files:   ${task.context.files.join(", ")}`);
+    console.log(`  objective: ${task.objective}`);
+  }
+  const result = task.result;
+  if (!result) return;
+  if (result.summary) console.log(`  summary: ${result.summary}`);
+  if (result.reports && result.reports.length > 0) {
+    console.log(`  reports: ${result.reports.length} structured report(s)`);
+  }
+  if (result.error) console.log(`  error:   ${result.error}`);
+  if (result.finishedAt) console.log(`  ended:   ${result.finishedAt}`);
+}
+function truncate(text, max) {
+  return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+}
 
 // src/cli/commands/reports.ts
 function registerReportCommands(program) {