@hilbras/omninode 0.0.0-stage → 0.2.0

package/dist/cli/index.js

@@ -0,0 +1,842 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { pathToFileURL } from "url";
+import { realpathSync } from "fs";
+import { Command } from "commander";
+
+// src/version.ts
+var OMNINODE_VERSION = "0.2.0";
+
+// src/errors/index.ts
+var OmniNodeError = class extends Error {
+  code;
+  details;
+  constructor(code, message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = new.target.name;
+    this.code = code;
+    this.details = options.details;
+  }
+};
+var ConfigError = class extends OmniNodeError {
+  constructor(code, message, options = {}) {
+    super(code, message, options);
+  }
+};
+var ProviderError = class extends OmniNodeError {
+  constructor(code, message, options = {}) {
+    super(code, message, options);
+  }
+};
+function isOmniNodeError(value) {
+  return value instanceof OmniNodeError;
+}
+
+// src/cli/commands/init.ts
+import { existsSync as existsSync2, writeFileSync } from "fs";
+
+// src/config/schema.ts
+import { z } from "zod";
+var providerConfigSchema = z.object({
+  name: z.string().min(1),
+  type: z.enum(["openai-compatible", "omnihilbras", "openrouter", "local", "custom"]),
+  base_url: z.string().url(),
+  api_key_env_var: z.string().min(1).optional(),
+  headers: z.record(z.string()).optional(),
+  enabled: z.boolean().optional(),
+  metadata: z.record(z.unknown()).optional()
+}).strict();
+var agentConfigSchema = z.object({
+  name: z.string().min(1),
+  /** "cli" agents communicate over stdin/stdout (process adapter). */
+  type: z.enum(["cli", "native", "process"]).default("cli"),
+  command: z.string().min(1).optional(),
+  args: z.array(z.string()).optional(),
+  cwd: z.string().optional(),
+  env: z.record(z.string()).optional(),
+  metadata: z.record(z.unknown()).optional()
+}).strict();
+var roleConfigSchema = z.object({
+  id: z.string().min(1).regex(/^[a-z0-9][a-z0-9-]*$/, "role id must be kebab-case"),
+  name: z.string().min(1),
+  description: z.string().optional(),
+  responsibilities: z.array(z.string()).default([]),
+  expected_outputs: z.array(z.string()).default([]),
+  preferred_agents: z.array(z.string()).optional(),
+  system_prompt: z.string().optional(),
+  metadata: z.record(z.unknown()).optional()
+}).strict();
+var projectConfigSchema = z.object({
+  name: z.string().min(1),
+  providers: z.array(providerConfigSchema).default([]),
+  agents: z.array(agentConfigSchema).default([]),
+  roles: z.array(roleConfigSchema).default([]),
+  memory: z.object({ provider: z.string().min(1) }).strict().optional()
+}).strict();
+var appConfigSchema = z.object({
+  project: projectConfigSchema,
+  logging: z.object({ level: z.enum(["debug", "info", "warn", "error"]) }).strict().optional()
+}).strict();
+
+// src/config/loader.ts
+import { existsSync, readFileSync } from "fs";
+import { parse as parseYaml } from "yaml";
+var CONFIG_FILENAMES = ["omninode.yaml", "omninode.yml", "omninode.json"];
+function findConfigFile(directory = process.cwd()) {
+  for (const filename of CONFIG_FILENAMES) {
+    const candidate = `${directory}/${filename}`;
+    if (existsSync(candidate)) return candidate;
+  }
+  return void 0;
+}
+function expandEnvRefs(text, env, source = "config") {
+  return text.replace(
+    /\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g,
+    (_match, name, fallback) => {
+      const value = env[name] ?? fallback;
+      if (value === void 0) {
+        throw new ConfigError(
+          "CONFIG_INVALID",
+          `Environment variable "${name}" is referenced in ${source} but is not set and has no default.`
+        );
+      }
+      return value;
+    }
+  );
+}
+function loadConfig(options = {}) {
+  const env = options.env ?? process.env;
+  const path = options.path ?? (options.directory ? findConfigFile(options.directory) : findConfigFile());
+  if (!path) {
+    throw new ConfigError(
+      "CONFIG_NOT_FOUND",
+      "No omninode.yaml found. Run `omninode init` to create one, or pass an explicit path."
+    );
+  }
+  const raw = readFileSync(path, "utf8");
+  const expanded = expandEnvRefs(raw, env, path);
+  let data;
+  try {
+    data = parseYaml(expanded);
+  } catch (error) {
+    throw new ConfigError("CONFIG_INVALID", `Failed to parse ${path}.`, { cause: error });
+  }
+  const parsed = appConfigSchema.safeParse(data);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((issue) => {
+      const location = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+      return `${location}: ${issue.message}`;
+    });
+    throw new ConfigError("CONFIG_INVALID", `Invalid configuration in ${path}.`, {
+      details: { issues }
+    });
+  }
+  return toAppConfig(parsed.data);
+}
+function toAppConfig(yaml) {
+  return {
+    project: {
+      name: yaml.project.name,
+      providers: yaml.project.providers.map(toProviderConfig),
+      agents: yaml.project.agents.map(toAgentConfig),
+      roles: yaml.project.roles.map(toRoleDefinition),
+      ...yaml.project.memory !== void 0 ? { memory: yaml.project.memory } : {}
+    },
+    ...yaml.logging !== void 0 ? { logging: yaml.logging } : {}
+  };
+}
+function toProviderConfig(raw) {
+  return {
+    name: raw.name,
+    type: raw.type,
+    baseUrl: raw.base_url,
+    apiKeyEnvVar: raw.api_key_env_var,
+    headers: raw.headers,
+    enabled: raw.enabled,
+    metadata: raw.metadata
+  };
+}
+function toAgentConfig(raw) {
+  const integration = raw.type === "native" ? "native" : "process";
+  return {
+    name: raw.name,
+    integration,
+    command: raw.command,
+    args: raw.args,
+    cwd: raw.cwd,
+    env: raw.env,
+    metadata: raw.metadata
+  };
+}
+function toRoleDefinition(raw) {
+  return {
+    id: raw.id,
+    name: raw.name,
+    description: raw.description,
+    responsibilities: raw.responsibilities,
+    expectedOutputs: raw.expected_outputs,
+    preferredAgents: raw.preferred_agents,
+    systemPrompt: raw.system_prompt,
+    metadata: raw.metadata
+  };
+}
+
+// src/config/default.ts
+function defaultProjectConfigYaml(projectName = "My Project") {
+  return `project:
+  name: ${projectName}
+
+  # Providers connect OmniNode to AI model gateways (Phase 1+).
+  # Credentials are referenced by environment variable, never stored in this file.
+  providers: []
+  #  - name: my-gateway
+  #    type: openai-compatible
+  #    base_url: https://example.com/v1
+  #    api_key_env_var: MY_API_KEY
+
+  # CLI agents registered with OmniNode (Phase 3 wires them up).
+  agents: []
+  #  - name: opencode
+  #    type: cli
+  #    command: opencode
+
+  # Roles describe what an AI is supposed to do (Phase 4).
+  roles: []
+  #  - id: architecture-reviewer
+  #    name: Architecture Reviewer
+  #    responsibilities:
+  #      - architecture analysis
+  #    expected_outputs:
+  #      - findings
+  #      - recommendations
+
+  # Memory is optional; Remembera is the preferred integration (Phase 7).
+  # memory:
+  #   provider: remembera
+`;
+}
+
+// src/cli/commands/init.ts
+async function runInit(options) {
+  const target = `${process.cwd()}/omninode.yaml`;
+  if (!options.force && existsSync2(target)) {
+    throw new OmniNodeError(
+      "CLI_USAGE",
+      `${target} already exists. Use --force to overwrite it.`
+    );
+  }
+  writeFileSync(target, defaultProjectConfigYaml(options.name), "utf8");
+  console.log(`Created ${target}`);
+  console.log("\nNext steps:");
+  console.log("  1. Add a provider under `project.providers` (see omninode.yaml.example).");
+  console.log("  2. Register CLI agents under `project.agents`.");
+  console.log("  3. Run `omninode provider list` to validate the configuration.");
+}
+function registerInitCommand(program) {
+  program.command("init").description("Create an omninode.yaml project configuration in the current directory.").option("-f, --force", "Overwrite an existing omninode.yaml.").option("-n, --name <name>", "Project name to write into the configuration.", "My Project").action(async (options) => runInit(options));
+}
+
+// src/cli/commands/project.ts
+function registerProjectCommands(program) {
+  const project = program.command("project").description("Project-level operations.");
+  project.command("init").description("Alias of `omninode init`.").option("-f, --force", "Overwrite an existing omninode.yaml.").option("-n, --name <name>", "Project name to write into the configuration.", "My Project").action(async (options) => runInit(options));
+}
+
+// src/cli/commands/providers.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { parseDocument } from "yaml";
+
+// src/providers/auth.ts
+function resolveApiKey(config, env = process.env) {
+  if (!config.apiKeyEnvVar) return void 0;
+  const value = env[config.apiKeyEnvVar];
+  if (!value) {
+    throw new ProviderError(
+      "PROVIDER_AUTH_FAILED",
+      `Environment variable "${config.apiKeyEnvVar}" (referenced by provider "${config.name}") is not set.`
+    );
+  }
+  return value;
+}
+function authHeaders(config, env = process.env) {
+  const key = resolveApiKey(config, env);
+  const base = { ...config.headers ?? {} };
+  return key ? { ...base, authorization: `Bearer ${key}` } : base;
+}
+
+// src/providers/http.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+async function requestJson(url, options = {}) {
+  const { method = "GET", headers = {}, body, timeoutMs = DEFAULT_TIMEOUT_MS } = options;
+  let response;
+  try {
+    response = await fetch(url, {
+      method,
+      headers: {
+        accept: "application/json",
+        ...body !== void 0 ? { "content-type": "application/json" } : {},
+        ...headers
+      },
+      ...body !== void 0 ? { body: JSON.stringify(body) } : {},
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch (error) {
+    const reason = error instanceof Error && error.name === "TimeoutError" ? `timed out after ${timeoutMs}ms` : error instanceof Error ? error.message : String(error);
+    throw new ProviderError("PROVIDER_UNAVAILABLE", `Request to ${url} failed: ${reason}.`, {
+      cause: error
+    });
+  }
+  let parsed;
+  try {
+    parsed = await response.json();
+  } catch (error) {
+    throw new ProviderError("PROVIDER_UNAVAILABLE", `Response from ${url} was not valid JSON.`, {
+      cause: error,
+      details: { status: response.status }
+    });
+  }
+  return { status: response.status, body: parsed };
+}
+
+// src/logger/index.ts
+var LEVEL_ORDER = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+var ConsoleLogSink = class {
+  constructor(stream = process.stderr) {
+    this.stream = stream;
+  }
+  stream;
+  write(_level, line) {
+    this.stream.write(line + "\n");
+  }
+};
+var Logger = class _Logger {
+  level;
+  sink;
+  context;
+  constructor(options = {}) {
+    this.level = options.level ?? "info";
+    this.sink = options.sink ?? new ConsoleLogSink();
+    this.context = options.context ?? {};
+  }
+  child(context) {
+    return new _Logger({
+      level: this.level,
+      sink: this.sink,
+      context: { ...this.context, ...context }
+    });
+  }
+  debug(message, data) {
+    this.log("debug", message, data);
+  }
+  info(message, data) {
+    this.log("info", message, data);
+  }
+  warn(message, data) {
+    this.log("warn", message, data);
+  }
+  error(message, data) {
+    this.log("error", message, data);
+  }
+  log(level, message, data) {
+    if (LEVEL_ORDER[level] < LEVEL_ORDER[this.level]) return;
+    const parts = [(/* @__PURE__ */ new Date()).toISOString(), level.toUpperCase(), message];
+    const merged = { ...this.context, ...data };
+    if (Object.keys(merged).length > 0) {
+      parts.push(JSON.stringify(merged));
+    }
+    this.sink.write(level, parts.join(" "));
+  }
+};
+var logger = new Logger();
+
+// src/providers/openai-compatible/index.ts
+var OpenAICompatibleProvider = class {
+  config;
+  log;
+  constructor(config, log = logger) {
+    this.config = { ...config, baseUrl: normalizeBaseUrl(config.baseUrl) };
+    this.log = log.child({ provider: config.name });
+  }
+  async listModels() {
+    const { status, body } = await requestJson(`${this.config.baseUrl}/models`, {
+      headers: authHeaders(this.config)
+    });
+    if (status === 401 || status === 403) {
+      throw authFailed(this.config, status);
+    }
+    if (status !== 200) {
+      throw unavailable(this.config, `Model discovery returned HTTP ${status}.`, status);
+    }
+    const entries = extractModelEntries(body, this.config);
+    const models = [];
+    let skipped = 0;
+    for (const entry2 of entries) {
+      if (typeof entry2.id !== "string" || entry2.id.length === 0) {
+        skipped += 1;
+        continue;
+      }
+      models.push({
+        provider: this.config.name,
+        id: entry2.id,
+        displayName: entry2.id,
+        status: "available",
+        metadata: {
+          ...typeof entry2.owned_by === "string" ? { ownedBy: entry2.owned_by } : {},
+          ...typeof entry2.created === "number" ? { createdAt: entry2.created } : {}
+        }
+      });
+    }
+    if (skipped > 0) {
+      this.log.warn(`Skipped ${skipped} model entr(y/ies) without a valid id.`);
+    }
+    return models;
+  }
+  async healthCheck() {
+    const lastCheckedAt = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      const started = Date.now();
+      const models = await this.listModels();
+      return {
+        name: this.config.name,
+        type: this.config.type,
+        baseUrl: this.config.baseUrl,
+        health: "healthy",
+        connected: true,
+        modelCount: models.length,
+        lastCheckedAt,
+        message: `Discovered ${models.length} model(s) in ${Date.now() - started}ms.`
+      };
+    } catch (error) {
+      return {
+        name: this.config.name,
+        type: this.config.type,
+        baseUrl: this.config.baseUrl,
+        health: inferHealth(error),
+        connected: false,
+        modelCount: 0,
+        lastCheckedAt,
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async chat(request) {
+    const { status, body } = await requestJson(`${this.config.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: authHeaders(this.config),
+      body: {
+        model: request.model,
+        messages: request.messages,
+        ...request.temperature !== void 0 ? { temperature: request.temperature } : {},
+        ...request.maxTokens !== void 0 ? { max_tokens: request.maxTokens } : {},
+        ...request.stop !== void 0 ? { stop: request.stop } : {}
+      }
+    });
+    if (status === 401 || status === 403) throw authFailed(this.config, status);
+    if (status === 404) {
+      throw new ProviderError(
+        "MODEL_NOT_FOUND",
+        `Model "${request.model}" or the chat endpoint was not found on provider "${this.config.name}" (HTTP 404).`,
+        { details: { status } }
+      );
+    }
+    if (status !== 200) {
+      throw unavailable(this.config, `Chat completion returned HTTP ${status}.`, status);
+    }
+    const payload = body;
+    const choices = Array.isArray(payload.choices) ? payload.choices : [];
+    const first = choices[0];
+    if (!first || typeof first.message?.content !== "string") {
+      throw unavailable(this.config, "Chat completion response had no message content.", status);
+    }
+    const usage = payload.usage ?? {};
+    return {
+      model: typeof payload.model === "string" ? payload.model : request.model,
+      content: first.message.content,
+      finishReason: typeof first.finish_reason === "string" ? first.finish_reason : void 0,
+      usage: {
+        promptTokens: typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : void 0,
+        completionTokens: typeof usage.completion_tokens === "number" ? usage.completion_tokens : void 0,
+        totalTokens: typeof usage.total_tokens === "number" ? usage.total_tokens : void 0
+      },
+      raw: body
+    };
+  }
+};
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/+$/, "");
+}
+function extractModelEntries(body, config) {
+  if (Array.isArray(body)) return body;
+  if (body !== null && typeof body === "object" && Array.isArray(body.data)) {
+    return body.data;
+  }
+  throw new ProviderError(
+    "PROVIDER_UNAVAILABLE",
+    `Provider "${config.name}" returned an unrecognized model list shape.`,
+    { details: { endpoint: "models" } }
+  );
+}
+function authFailed(config, status) {
+  const envHint = config.apiKeyEnvVar ? ` Check that $${config.apiKeyEnvVar} is set and valid.` : " The provider requires authentication; configure api_key_env_var for it.";
+  return new ProviderError(
+    "PROVIDER_AUTH_FAILED",
+    `Authentication with provider "${config.name}" failed (HTTP ${status}).${envHint}`,
+    { details: { status } }
+  );
+}
+function unavailable(config, message, status) {
+  return new ProviderError("PROVIDER_UNAVAILABLE", `Provider "${config.name}": ${message}`, {
+    details: { status }
+  });
+}
+function inferHealth(error) {
+  const status = error instanceof ProviderError && typeof error.details?.status === "number" ? error.details.status : void 0;
+  return status !== void 0 && status >= 500 ? "degraded" : "unreachable";
+}
+
+// src/providers/factory.ts
+var OPENAI_COMPATIBLE_TYPES = [
+  "openai-compatible",
+  "openrouter",
+  "local",
+  "custom"
+];
+function createProvider(config) {
+  if (OPENAI_COMPATIBLE_TYPES.includes(config.type)) {
+    return new OpenAICompatibleProvider(config);
+  }
+  if (config.type === "omnihilbras") {
+    throw new OmniNodeError(
+      "NOT_IMPLEMENTED",
+      `Provider type "omnihilbras" is planned for Phase 2 (OmniHilbras Integration). If your OmniHilbras endpoint is OpenAI-compatible, use type "openai-compatible" for now.`
+    );
+  }
+  throw new OmniNodeError("NOT_IMPLEMENTED", `Provider type "${config.type}" has no adapter yet.`);
+}
+
+// src/cli/commands/shared.ts
+function notImplemented(command, when) {
+  return new OmniNodeError(
+    "NOT_IMPLEMENTED",
+    `${command} is planned for ${when}. Edit omninode.yaml directly for now.`
+  );
+}
+
+// src/cli/commands/providers.ts
+function registerProviderCommands(program) {
+  const provider = program.command("provider").description("Manage AI providers configured in omninode.yaml.");
+  provider.command("list").description("List configured providers.").action(async () => {
+    const config = loadConfig();
+    const providers = config.project.providers;
+    if (providers.length === 0) {
+      console.log(
+        "No providers configured. Add one with `omninode provider add` or edit omninode.yaml."
+      );
+      return;
+    }
+    for (const provider2 of providers) {
+      const key = provider2.apiKeyEnvVar ? `$${provider2.apiKeyEnvVar}` : "none";
+      const enabled = provider2.enabled === false ? "  (disabled)" : "";
+      console.log(
+        `${provider2.name}  type=${provider2.type}  base_url=${provider2.baseUrl}  key=${key}${enabled}`
+      );
+    }
+  });
+  provider.command("add").description(
+    "Add a provider to omninode.yaml. OpenAI-compatible gateways (including OpenRouter and local runtimes) are supported today; OmniHilbras gets its own adapter in Phase 2."
+  ).requiredOption("--name <name>", "Unique provider name used in configuration and the model registry.").requiredOption("--base-url <url>", "Provider base URL, e.g. https://example.com/v1").option(
+    "--type <type>",
+    "Provider type: openai-compatible, omnihilbras, openrouter, local or custom.",
+    "openai-compatible"
+  ).option(
+    "--api-key-env-var <envVar>",
+    "Environment variable holding the API key. Keys are never written to the config file."
+  ).action(async (options) => addProvider(options));
+  provider.command("test <name>").description("Test connectivity, authentication and model discovery for a configured provider.").action(async (name) => testProvider(name));
+  provider.command("remove <name>").description("Remove a provider (planned for Phase 1 follow-up).").action(() => {
+    throw notImplemented("omninode provider remove", "a Phase 1 follow-up");
+  });
+}
+async function addProvider(options) {
+  const configPath = findConfigFile();
+  if (!configPath) {
+    throw new OmniNodeError("CONFIG_NOT_FOUND", "No omninode.yaml found. Run `omninode init` first.");
+  }
+  const candidate = providerConfigSchema.safeParse({
+    name: options.name,
+    type: options.type,
+    base_url: options.baseUrl,
+    ...options.apiKeyEnvVar !== void 0 ? { api_key_env_var: options.apiKeyEnvVar } : {}
+  });
+  if (!candidate.success) {
+    const issues = candidate.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
+    throw new OmniNodeError("CLI_USAGE", `Invalid provider options: ${issues}`);
+  }
+  const newProvider = candidate.data;
+  const existing = loadConfig();
+  if (existing.project.providers.some((p) => p.name === newProvider.name)) {
+    throw new OmniNodeError(
+      "CLI_USAGE",
+      `Provider "${newProvider.name}" already exists in ${configPath}.`
+    );
+  }
+  const doc = parseDocument(readFileSync2(configPath, "utf8"));
+  if (doc.getIn(["project", "providers"]) === void 0) {
+    doc.setIn(["project", "providers"], [newProvider]);
+  } else {
+    doc.addIn(["project", "providers"], newProvider);
+  }
+  const validated = appConfigSchema.safeParse(doc.toJS());
+  if (!validated.success) {
+    const issues = validated.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
+    throw new ConfigError(
+      "CONFIG_INVALID",
+      `Editing ${configPath} would produce an invalid configuration: ${issues}`
+    );
+  }
+  writeFileSync2(configPath, doc.toString(), "utf8");
+  console.log(`Added provider "${newProvider.name}" (${newProvider.type}) to ${configPath}.`);
+  if (newProvider.api_key_env_var) {
+    console.log(
+      `Set $${newProvider.api_key_env_var} in your environment, then run: omninode provider test ${newProvider.name}`
+    );
+  } else {
+    console.log(`Run \`omninode provider test ${newProvider.name}\` to verify connectivity.`);
+  }
+}
+async function testProvider(name) {
+  const config = loadConfig();
+  const providerConfig = config.project.providers.find((p) => p.name === name);
+  if (!providerConfig) {
+    const available = config.project.providers.map((p) => p.name).join(", ") || "(none)";
+    throw new ProviderError(
+      "PROVIDER_NOT_FOUND",
+      `Provider "${name}" is not configured. Configured providers: ${available}.`
+    );
+  }
+  const provider = createProvider(providerConfig);
+  console.log(`Testing provider "${name}" (${providerConfig.type}) at ${provider.config.baseUrl}`);
+  const health = await provider.healthCheck();
+  console.log(`  health:    ${health.health}`);
+  console.log(`  connected: ${health.connected}`);
+  console.log(`  models:    ${health.modelCount}`);
+  if (health.message) console.log(`  detail:    ${health.message}`);
+  if (!health.connected) process.exitCode = 1;
+}
+
+// src/registry/index.ts
+function registryKey(provider, id) {
+  return `${provider}:${id}`;
+}
+var ModelRegistry = class {
+  models = /* @__PURE__ */ new Map();
+  register(model) {
+    this.models.set(registryKey(model.provider, model.id), model);
+  }
+  get(provider, id) {
+    return this.models.get(registryKey(provider, id));
+  }
+  list(filter = {}) {
+    return [...this.models.values()].filter((model) => filter.provider ? model.provider === filter.provider : true).filter(
+      (model) => filter.capability ? model.capabilities?.[filter.capability] === true : true
+    ).sort((a, b) => a.provider.localeCompare(b.provider) || a.id.localeCompare(b.id));
+  }
+  /** Availability validation (§27 Phase 1): present in the registry and not retired. */
+  isAvailable(provider, id) {
+    const model = this.get(provider, id);
+    return model !== void 0 && (model.status ?? "available") === "available";
+  }
+  /** Discover models from one provider and register them. */
+  async discoverFrom(provider) {
+    const discovered = await provider.listModels();
+    for (const model of discovered) this.register(model);
+    return discovered;
+  }
+  /** Discover from many providers; a failing provider does not abort the rest. */
+  async discoverAll(providers) {
+    return Promise.all(
+      providers.map(async (provider) => {
+        try {
+          return {
+            provider: provider.config.name,
+            models: await this.discoverFrom(provider)
+          };
+        } catch (error) {
+          return {
+            provider: provider.config.name,
+            models: [],
+            error: error instanceof Error ? error : new Error(String(error))
+          };
+        }
+      })
+    );
+  }
+};
+
+// src/cli/commands/models.ts
+var CAPABILITIES = [
+  "chat",
+  "coding",
+  "tools",
+  "vision",
+  "embeddings"
+];
+function registerModelsCommand(program) {
+  program.command("models").description("Discover and list models from configured providers (model registry, \xA78).").argument("[provider]", "Only discover from this provider.").option("-c, --capability <capability>", `Filter by capability: ${CAPABILITIES.join(", ")}.`).action(async (providerName, options) => {
+    const capability = options.capability;
+    if (capability !== void 0 && !CAPABILITIES.includes(capability)) {
+      throw new OmniNodeError(
+        "CLI_USAGE",
+        `Unknown capability "${options.capability}". Valid capabilities: ${CAPABILITIES.join(", ")}.`
+      );
+    }
+    const config = loadConfig();
+    const selected = config.project.providers.filter(
+      (p) => providerName ? p.name === providerName : true
+    );
+    if (selected.length === 0) {
+      throw new OmniNodeError(
+        "PROVIDER_NOT_FOUND",
+        providerName ? `Provider "${providerName}" is not configured.` : "No providers configured. Add one with `omninode provider add`."
+      );
+    }
+    const registry = new ModelRegistry();
+    for (const providerConfig of selected) {
+      try {
+        const provider = createProvider(providerConfig);
+        const discovered = await registry.discoverFrom(provider);
+        console.log(`${providerConfig.name}: ${discovered.length} model(s)`);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.log(`${providerConfig.name}: discovery failed \u2014 ${message}`);
+      }
+    }
+    const models = registry.list({
+      ...providerName !== void 0 ? { provider: providerName } : {},
+      ...capability !== void 0 ? { capability } : {}
+    });
+    if (models.length === 0) {
+      console.log("No models found.");
+      return;
+    }
+    console.log("");
+    for (const model of models) {
+      console.log(`${model.provider}:${model.id}`);
+    }
+  });
+}
+
+// src/cli/commands/agents.ts
+function registerAgentCommands(program) {
+  const agent = program.command("agent").description("Manage CLI agents registered with OmniNode.");
+  agent.command("list").description("List configured agents.").action(async () => {
+    const config = loadConfig();
+    const agents = config.project.agents;
+    if (agents.length === 0) {
+      console.log("No agents configured. Add one under `project.agents` in omninode.yaml.");
+      return;
+    }
+    for (const agent2 of agents) {
+      const command = agent2.command ?? "(no command)";
+      console.log(
+        `${agent2.name}  integration=${agent2.integration}  command=${command}`
+      );
+    }
+  });
+  agent.command("add").description("Register an agent (planned for Phase 3 \u2014 CLI Agent System).").action(() => {
+    throw notImplemented("omninode agent add", "Phase 3 (CLI Agent System)");
+  });
+}
+
+// src/cli/commands/roles.ts
+function registerRoleCommands(program) {
+  const role = program.command("role").description("Inspect roles defined in omninode.yaml.");
+  role.command("list").description("List configured roles.").action(async () => {
+    const config = loadConfig();
+    const roles = config.project.roles;
+    if (roles.length === 0) {
+      console.log("No roles configured. Add one under `project.roles` in omninode.yaml.");
+      return;
+    }
+    for (const role2 of roles) {
+      console.log(`${role2.id}  ${role2.name}`);
+      for (const responsibility of role2.responsibilities) {
+        console.log(`  - ${responsibility}`);
+      }
+    }
+  });
+}
+
+// src/cli/commands/tasks.ts
+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)");
+  });
+  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("status <task-id>").description("Show task status (planned for Phase 4 \u2014 Roles & Tasks).").action(() => {
+    throw notImplemented("omninode task status", "Phase 4 (Roles & Tasks)");
+  });
+}
+
+// src/cli/commands/reports.ts
+function registerReportCommands(program) {
+  const report = program.command("report").description("Inspect AI reports (Phase 6+).");
+  report.command("list").description("List collected reports (planned for Phase 6 \u2014 Multi-AI Report System).").action(() => {
+    throw notImplemented("omninode report list", "Phase 6 (Multi-AI Report System)");
+  });
+}
+
+// src/cli/index.ts
+function createProgram() {
+  const program = new Command();
+  program.name("omninode").description(
+    "Provider-agnostic multi-AI orchestration platform: coordinate CLI agents, AI providers, memory, roles, reports and planning in one execution system."
+  ).version(OMNINODE_VERSION, "-v, --version", "Print the OmniNode version.");
+  registerInitCommand(program);
+  registerProjectCommands(program);
+  registerProviderCommands(program);
+  registerAgentCommands(program);
+  registerRoleCommands(program);
+  registerTaskCommands(program);
+  registerReportCommands(program);
+  registerModelsCommand(program);
+  return program;
+}
+async function run(argv) {
+  const program = createProgram();
+  try {
+    await program.parseAsync(argv);
+  } catch (error) {
+    handleError(error);
+  }
+}
+function handleError(error) {
+  if (isOmniNodeError(error)) {
+    console.error(`error: [${error.code}] ${error.message}`);
+    if (error.details !== void 0) {
+      console.error(JSON.stringify(error.details, null, 2));
+    }
+    process.exit(1);
+  }
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+}
+var entry = process.argv[1] ? pathToFileURL(realpathSync(process.argv[1])).href : "";
+if (import.meta.url === entry) {
+  run(process.argv).catch((error) => handleError(error));
+}
+export {
+  createProgram,
+  handleError,
+  run
+};
+//# sourceMappingURL=index.js.map