viben 0.1.0

package/dist/index.js

@@ -0,0 +1,1102 @@
+// src/cli.ts
+import { Command } from "commander";
+import { createRequire } from "module";
+
+// src/commands/init.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import chalk2 from "chalk";
+
+// src/types/index.ts
+var CliError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "CliError";
+  }
+  toResponse() {
+    return {
+      success: false,
+      error: {
+        code: this.code,
+        message: this.message,
+        details: this.details
+      }
+    };
+  }
+};
+
+// src/lib/config.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as yaml from "yaml";
+
+// src/lib/scope.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+var WORKSPACE_DIR = ".viben";
+var CONFIG_FILE = "config.yaml";
+function getGlobalConfigDir() {
+  return process.env.VIBEN_STATE_DIR || path.join(os.homedir(), WORKSPACE_DIR);
+}
+var GLOBAL_CONFIG_DIR = getGlobalConfigDir();
+function getStateDir() {
+  return getGlobalConfigDir();
+}
+function findWorkspaceRoot(startDir) {
+  let currentDir = path.resolve(startDir);
+  const root = path.parse(currentDir).root;
+  while (currentDir !== root) {
+    const vibenDir = path.join(currentDir, WORKSPACE_DIR);
+    const configPath = path.join(vibenDir, CONFIG_FILE);
+    if (fs.existsSync(configPath)) {
+      return currentDir;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+  return null;
+}
+function getWorkspaceDir() {
+  const workspaceRoot = findWorkspaceRoot(process.cwd());
+  if (workspaceRoot) {
+    return path.join(workspaceRoot, WORKSPACE_DIR);
+  }
+  return null;
+}
+function resolveScope(options = {}) {
+  if (options.global) {
+    return "global";
+  }
+  if (options.workspace) {
+    return "workspace";
+  }
+  const envScope = process.env.VIBEN_SCOPE;
+  if (envScope === "global" || envScope === "workspace") {
+    return envScope;
+  }
+  const workspaceDir = getWorkspaceDir();
+  if (workspaceDir) {
+    return "workspace";
+  }
+  return "global";
+}
+function getConfigPathForScope(scope) {
+  if (scope === "workspace") {
+    const workspaceDir = getWorkspaceDir();
+    if (!workspaceDir) {
+      throw new CliError(
+        'Not in a workspace. Use --global or run "viben init" first.',
+        "NO_WORKSPACE"
+      );
+    }
+    return path.join(workspaceDir, CONFIG_FILE);
+  }
+  const globalDir = getGlobalConfigDir();
+  return path.join(globalDir, CONFIG_FILE);
+}
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+// src/lib/config.ts
+var DEFAULT_CONFIG = {
+  version: 1,
+  settings: {
+    editor: "code",
+    pager: "less",
+    color: "auto"
+  },
+  agents: [],
+  mcp: {
+    enabled: []
+  },
+  skills: {
+    enabled: []
+  }
+};
+function readConfigFile(filePath) {
+  if (!fs2.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const content = fs2.readFileSync(filePath, "utf-8");
+    return yaml.parse(content);
+  } catch (error) {
+    throw new CliError(
+      `Failed to read config file: ${filePath}`,
+      "CONFIG_READ_ERROR",
+      error
+    );
+  }
+}
+function writeConfigFile(filePath, config) {
+  try {
+    const dirPath = path2.dirname(filePath);
+    ensureDir(dirPath);
+    const content = yaml.stringify(config, {
+      indent: 2,
+      lineWidth: 0
+      // Don't wrap lines
+    });
+    fs2.writeFileSync(filePath, content, "utf-8");
+  } catch (error) {
+    throw new CliError(
+      `Failed to write config file: ${filePath}`,
+      "CONFIG_WRITE_ERROR",
+      error
+    );
+  }
+}
+function readScopedConfig(scope) {
+  const configPath = getConfigPathForScope(scope);
+  return readConfigFile(configPath);
+}
+function writeScopedConfig(scope, config) {
+  const configPath = getConfigPathForScope(scope);
+  writeConfigFile(configPath, config);
+}
+function getConfigValue(config, key) {
+  const parts = parseKey(key);
+  let current = config;
+  for (const part of parts) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    if (typeof current !== "object") {
+      return void 0;
+    }
+    if (part.isArrayIndex) {
+      if (!Array.isArray(current)) {
+        return void 0;
+      }
+      current = current[part.index];
+    } else {
+      current = current[part.key];
+    }
+  }
+  return current;
+}
+function setConfigValue(config, key, value) {
+  const parts = parseKey(key);
+  if (parts.length === 0) {
+    return config;
+  }
+  const newConfig = JSON.parse(JSON.stringify(config));
+  let current = newConfig;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    const nextPart = parts[i + 1];
+    if (part.isArrayIndex) {
+      const arr = current;
+      if (!Array.isArray(arr)) {
+        throw new CliError(`Cannot index non-array at ${key}`, "INVALID_KEY");
+      }
+      if (arr[part.index] === void 0) {
+        arr[part.index] = nextPart.isArrayIndex ? [] : {};
+      }
+      current = arr[part.index];
+    } else {
+      if (current[part.key] === void 0 || typeof current[part.key] !== "object") {
+        current[part.key] = nextPart.isArrayIndex ? [] : {};
+      }
+      current = current[part.key];
+    }
+  }
+  const lastPart = parts[parts.length - 1];
+  if (lastPart.isArrayIndex) {
+    const arr = current;
+    arr[lastPart.index] = value;
+  } else {
+    current[lastPart.key] = value;
+  }
+  return newConfig;
+}
+function deleteConfigValue(config, key) {
+  const parts = parseKey(key);
+  if (parts.length === 0) {
+    return config;
+  }
+  const newConfig = JSON.parse(JSON.stringify(config));
+  let current = newConfig;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (part.isArrayIndex) {
+      const arr = current;
+      if (!Array.isArray(arr) || arr[part.index] === void 0) {
+        return config;
+      }
+      current = arr[part.index];
+    } else {
+      if (current[part.key] === void 0 || typeof current[part.key] !== "object") {
+        return config;
+      }
+      current = current[part.key];
+    }
+  }
+  const lastPart = parts[parts.length - 1];
+  if (lastPart.isArrayIndex) {
+    const arr = current;
+    if (Array.isArray(arr)) {
+      arr.splice(lastPart.index, 1);
+    }
+  } else {
+    delete current[lastPart.key];
+  }
+  return newConfig;
+}
+function parseKey(key) {
+  const parts = [];
+  const regex = /([^.\[\]]+)|\[(\d+)\]/g;
+  let match;
+  while ((match = regex.exec(key)) !== null) {
+    if (match[1] !== void 0) {
+      parts.push({ key: match[1], isArrayIndex: false });
+    } else if (match[2] !== void 0) {
+      parts.push({ key: "", isArrayIndex: true, index: parseInt(match[2], 10) });
+    }
+  }
+  return parts;
+}
+function flattenConfig(config) {
+  const items = [];
+  function flatten(obj, prefix) {
+    if (obj === null || obj === void 0) {
+      return;
+    }
+    if (Array.isArray(obj)) {
+      obj.forEach((item, index) => {
+        const key = `${prefix}[${index}]`;
+        if (typeof item === "object" && item !== null) {
+          flatten(item, key);
+        } else {
+          items.push({ key, value: formatValue(item) });
+        }
+      });
+    } else if (typeof obj === "object") {
+      for (const [k, v] of Object.entries(obj)) {
+        const key = prefix ? `${prefix}.${k}` : k;
+        if (typeof v === "object" && v !== null) {
+          flatten(v, key);
+        } else {
+          items.push({ key, value: formatValue(v) });
+        }
+      }
+    } else {
+      items.push({ key: prefix, value: formatValue(obj) });
+    }
+  }
+  flatten(config, "");
+  return items;
+}
+function formatValue(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function getConfigWithOrigin() {
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  const workspaceDir = getWorkspaceDir();
+  if (workspaceDir) {
+    const workspaceConfigPath = path2.join(workspaceDir, CONFIG_FILE);
+    const workspaceConfig = readConfigFile(workspaceConfigPath);
+    if (workspaceConfig) {
+      const workspaceItems = flattenConfig(workspaceConfig);
+      for (const item of workspaceItems) {
+        items.push({ ...item, origin: "workspace" });
+        seen.add(item.key);
+      }
+    }
+  }
+  const globalDir = getGlobalConfigDir();
+  const globalConfigPath = path2.join(globalDir, CONFIG_FILE);
+  const globalConfig = readConfigFile(globalConfigPath);
+  if (globalConfig) {
+    const globalItems = flattenConfig(globalConfig);
+    for (const item of globalItems) {
+      if (!seen.has(item.key)) {
+        items.push({ ...item, origin: "global" });
+      }
+    }
+  }
+  return items;
+}
+function getEditor() {
+  if (process.env.VISUAL) {
+    return process.env.VISUAL;
+  }
+  if (process.env.EDITOR) {
+    return process.env.EDITOR;
+  }
+  const workspaceDir = getWorkspaceDir();
+  if (workspaceDir) {
+    const workspaceConfig = readConfigFile(path2.join(workspaceDir, CONFIG_FILE));
+    if (workspaceConfig?.settings?.editor) {
+      return workspaceConfig.settings.editor;
+    }
+  }
+  const globalDir = getGlobalConfigDir();
+  const globalConfig = readConfigFile(path2.join(globalDir, CONFIG_FILE));
+  if (globalConfig?.settings?.editor) {
+    return globalConfig.settings.editor;
+  }
+  return DEFAULT_CONFIG.settings?.editor || "vi";
+}
+
+// src/lib/output.ts
+import chalk from "chalk";
+function successResponse(data) {
+  return {
+    success: true,
+    data
+  };
+}
+function output(ctx, response, humanFn) {
+  if (ctx.json) {
+    console.log(JSON.stringify(response, null, 2));
+    return;
+  }
+  if (ctx.quiet && response.success) {
+    return;
+  }
+  humanFn();
+}
+function outputKeyValue(ctx, items) {
+  if (ctx.json) {
+    console.log(JSON.stringify(items, null, 2));
+    return;
+  }
+  for (const item of items) {
+    if (item.origin) {
+      console.log(`${chalk.gray(item.origin + ":")} ${chalk.cyan(item.key)}=${item.value}`);
+    } else {
+      console.log(`${chalk.cyan(item.key)}=${item.value}`);
+    }
+  }
+}
+function outputTable(ctx, headers, rows) {
+  if (ctx.json) {
+    const data = rows.map((row) => {
+      const obj = {};
+      headers.forEach((header, index) => {
+        obj[header.toLowerCase()] = row[index];
+      });
+      return obj;
+    });
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  const widths = headers.map((h, i) => {
+    const columnValues = [h, ...rows.map((r) => stripAnsi(r[i] || ""))];
+    return Math.max(...columnValues.map((v) => v.length));
+  });
+  const headerLine = headers.map((h, i) => h.padEnd(widths[i])).join("  ");
+  console.log(chalk.bold(headerLine));
+  const separator = widths.map((w) => "-".repeat(w)).join("  ");
+  console.log(chalk.gray(separator));
+  for (const row of rows) {
+    const rowLine = row.map((cell, i) => {
+      const stripped = stripAnsi(cell || "");
+      const padding = widths[i] - stripped.length;
+      return (cell || "") + " ".repeat(Math.max(0, padding));
+    }).join("  ");
+    console.log(rowLine);
+  }
+}
+function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function formatDate(dateStr) {
+  if (!dateStr) {
+    return chalk.gray("(unknown)");
+  }
+  try {
+    const date = new Date(dateStr);
+    const now = /* @__PURE__ */ new Date();
+    const diff = now.getTime() - date.getTime();
+    if (diff < 24 * 60 * 60 * 1e3) {
+      const hours = Math.floor(diff / (60 * 60 * 1e3));
+      if (hours === 0) {
+        const minutes = Math.floor(diff / (60 * 1e3));
+        if (minutes === 0) {
+          return "just now";
+        }
+        return `${minutes}m ago`;
+      }
+      return `${hours}h ago`;
+    }
+    if (diff < 7 * 24 * 60 * 60 * 1e3) {
+      const days = Math.floor(diff / (24 * 60 * 60 * 1e3));
+      return `${days}d ago`;
+    }
+    return date.toLocaleDateString();
+  } catch {
+    return dateStr;
+  }
+}
+
+// src/commands/init.ts
+function initWorkspace(targetDir, template) {
+  const vibenDir = path3.join(targetDir, WORKSPACE_DIR);
+  const configPath = path3.join(vibenDir, CONFIG_FILE);
+  if (fs3.existsSync(configPath)) {
+    throw new CliError(
+      'Workspace already initialized. Use "viben config" to modify settings.',
+      "WORKSPACE_EXISTS"
+    );
+  }
+  if (!fs3.existsSync(vibenDir)) {
+    fs3.mkdirSync(vibenDir, { recursive: true });
+  }
+  let config;
+  if (template) {
+    config = {
+      ...DEFAULT_CONFIG,
+      version: 1
+    };
+  } else {
+    config = {
+      ...DEFAULT_CONFIG,
+      version: 1
+    };
+  }
+  writeConfigFile(configPath, config);
+  const agentsDir = path3.join(vibenDir, "agents");
+  if (!fs3.existsSync(agentsDir)) {
+    fs3.mkdirSync(agentsDir, { recursive: true });
+  }
+  const mainAgentPath = path3.join(agentsDir, "main.yaml");
+  if (!fs3.existsSync(mainAgentPath)) {
+    const mainAgentConfig = `# Main agent configuration
+id: main
+name: Main Agent
+description: Default workspace agent
+
+# Model configuration (optional, uses defaults)
+# model: claude-sonnet-4-20250514
+# provider: anthropic
+`;
+    fs3.writeFileSync(mainAgentPath, mainAgentConfig, "utf-8");
+  }
+  return config;
+}
+function registerInitCommand(program) {
+  program.command("init").description("Initialize a Viben workspace in the current directory").option("--from <template>", "Initialize from a template").action(async (options) => {
+    const ctx = {
+      json: program.opts().json || false,
+      verbose: program.opts().verbose || false,
+      quiet: program.opts().quiet || false
+    };
+    try {
+      const targetDir = process.cwd();
+      const existingWorkspace = findWorkspaceRoot(targetDir);
+      if (existingWorkspace && existingWorkspace !== targetDir) {
+        throw new CliError(
+          `Already inside workspace at ${existingWorkspace}`,
+          "NESTED_WORKSPACE"
+        );
+      }
+      const config = initWorkspace(targetDir, options.from);
+      output(
+        ctx,
+        successResponse({
+          workspaceDir: path3.join(targetDir, WORKSPACE_DIR),
+          configPath: path3.join(targetDir, WORKSPACE_DIR, CONFIG_FILE),
+          config
+        }),
+        () => {
+          console.log(chalk2.green("Workspace initialized successfully!"));
+          console.log();
+          console.log("Created:");
+          console.log(chalk2.gray("  .viben/config.yaml") + "    - Workspace configuration");
+          console.log(chalk2.gray("  .viben/agents/main.yaml") + " - Default agent");
+          console.log();
+          console.log("Next steps:");
+          console.log(chalk2.cyan("  viben config list") + "      - View configuration");
+          console.log(chalk2.cyan("  viben agent list") + "       - List agents");
+          console.log(chalk2.cyan("  viben config set <key> <value>") + " - Modify settings");
+        }
+      );
+    } catch (error) {
+      if (error instanceof CliError) {
+        output(ctx, error.toResponse(), () => {
+          console.error(chalk2.red("Error:"), error.message);
+        });
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+}
+
+// src/commands/config.ts
+import { spawn } from "child_process";
+import chalk3 from "chalk";
+function parseValue(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function formatValue2(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function handleGet(ctx, scope, key) {
+  const config = readScopedConfig(scope) || DEFAULT_CONFIG;
+  const value = getConfigValue(config, key);
+  if (value === void 0) {
+    output(ctx, successResponse({ key, value: null }), () => {
+    });
+    return;
+  }
+  output(ctx, successResponse({ key, value }), () => {
+    console.log(formatValue2(value));
+  });
+}
+function handleSet(ctx, scope, key, value) {
+  const config = readScopedConfig(scope) || { version: 1 };
+  const parsedValue = parseValue(value);
+  const newConfig = setConfigValue(config, key, parsedValue);
+  writeScopedConfig(scope, newConfig);
+  output(ctx, successResponse({ key, value: parsedValue, scope }), () => {
+    console.log(chalk3.green("OK") + ` Set ${chalk3.cyan(key)} = ${formatValue2(parsedValue)}`);
+  });
+}
+function handleUnset(ctx, scope, key) {
+  const config = readScopedConfig(scope);
+  if (!config) {
+    throw new CliError(
+      `No config file found for scope: ${scope}`,
+      "CONFIG_NOT_FOUND"
+    );
+  }
+  const newConfig = deleteConfigValue(config, key);
+  writeScopedConfig(scope, newConfig);
+  output(ctx, successResponse({ key, scope }), () => {
+    console.log(chalk3.green("OK") + ` Unset ${chalk3.cyan(key)}`);
+  });
+}
+function handleList(ctx, scope, showOrigin) {
+  if (showOrigin) {
+    const items2 = getConfigWithOrigin();
+    output(ctx, successResponse({ items: items2 }), () => {
+      outputKeyValue(ctx, items2);
+    });
+    return;
+  }
+  const config = readScopedConfig(scope) || DEFAULT_CONFIG;
+  const items = flattenConfig(config);
+  output(ctx, successResponse({ items, scope }), () => {
+    for (const item of items) {
+      console.log(`${chalk3.cyan(item.key)}=${item.value}`);
+    }
+  });
+}
+async function handleEdit(ctx, scope) {
+  const configPath = getConfigPathForScope(scope);
+  const editor = getEditor();
+  output(ctx, successResponse({ configPath, editor }), () => {
+    console.log(`Opening ${chalk3.cyan(configPath)} in ${chalk3.yellow(editor)}...`);
+  });
+  const child = spawn(editor, [configPath], {
+    stdio: "inherit",
+    shell: true
+  });
+  return new Promise((resolve2, reject) => {
+    child.on("error", (error) => {
+      reject(new CliError(
+        `Failed to open editor: ${error.message}`,
+        "EDITOR_ERROR",
+        error
+      ));
+    });
+    child.on("close", () => {
+      resolve2();
+    });
+  });
+}
+function registerConfigCommand(program) {
+  const configCmd = program.command("config").description("Manage Viben configuration (git-style)");
+  configCmd.command("get <key>").description("Get a config value").option("-g, --global", "Use global config").option("-w, --workspace", "Use workspace config").action((key, options) => {
+    const ctx = {
+      json: program.opts().json || false,
+      verbose: program.opts().verbose || false,
+      quiet: program.opts().quiet || false
+    };
+    try {
+      const scope = resolveScope({
+        global: options.global || program.opts().global,
+        workspace: options.workspace || program.opts().workspace
+      });
+      handleGet(ctx, scope, key);
+    } catch (error) {
+      if (error instanceof CliError) {
+        output(ctx, error.toResponse(), () => {
+          console.error(chalk3.red("Error:"), error.message);
+        });
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+  configCmd.command("set <key> <value>").description("Set a config value").option("-g, --global", "Use global config").option("-w, --workspace", "Use workspace config").action((key, value, options) => {
+    const ctx = {
+      json: program.opts().json || false,
+      verbose: program.opts().verbose || false,
+      quiet: program.opts().quiet || false
+    };
+    try {
+      const scope = resolveScope({
+        global: options.global || program.opts().global,
+        workspace: options.workspace || program.opts().workspace
+      });
+      handleSet(ctx, scope, key, value);
+    } catch (error) {
+      if (error instanceof CliError) {
+        output(ctx, error.toResponse(), () => {
+          console.error(chalk3.red("Error:"), error.message);
+        });
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+  configCmd.command("unset <key>").description("Remove a config value").option("-g, --global", "Use global config").option("-w, --workspace", "Use workspace config").action((key, options) => {
+    const ctx = {
+      json: program.opts().json || false,
+      verbose: program.opts().verbose || false,
+      quiet: program.opts().quiet || false
+    };
+    try {
+      const scope = resolveScope({
+        global: options.global || program.opts().global,
+        workspace: options.workspace || program.opts().workspace
+      });
+      handleUnset(ctx, scope, key);
+    } catch (error) {
+      if (error instanceof CliError) {
+        output(ctx, error.toResponse(), () => {
+          console.error(chalk3.red("Error:"), error.message);
+        });
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+  configCmd.command("list").description("List all config values").option("-g, --global", "Use global config").option("-w, --workspace", "Use workspace config").option("--show-origin", "Show the origin of each config value").action((options) => {
+    const ctx = {
+      json: program.opts().json || false,
+      verbose: program.opts().verbose || false,
+      quiet: program.opts().quiet || false
+    };
+    try {
+      const scope = resolveScope({
+        global: options.global || program.opts().global,
+        workspace: options.workspace || program.opts().workspace
+      });
+      handleList(ctx, scope, options.showOrigin || false);
+    } catch (error) {
+      if (error instanceof CliError) {
+        output(ctx, error.toResponse(), () => {
+          console.error(chalk3.red("Error:"), error.message);
+        });
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+  configCmd.command("edit").description("Open config in editor").option("-g, --global", "Edit global config").option("-w, --workspace", "Edit workspace config").action(async (options) => {
+    const ctx = {
+      json: program.opts().json || false,
+      verbose: program.opts().verbose || false,
+      quiet: program.opts().quiet || false
+    };
+    try {
+      const scope = resolveScope({
+        global: options.global || program.opts().global,
+        workspace: options.workspace || program.opts().workspace
+      });
+      await handleEdit(ctx, scope);
+    } catch (error) {
+      if (error instanceof CliError) {
+        output(ctx, error.toResponse(), () => {
+          console.error(chalk3.red("Error:"), error.message);
+        });
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+}
+
+// src/commands/agent/index.ts
+import chalk7 from "chalk";
+
+// src/commands/agent/list.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import * as yaml2 from "yaml";
+import chalk4 from "chalk";
+function readAgentsFromDir(agentsDir, source) {
+  if (!fs4.existsSync(agentsDir)) {
+    return [];
+  }
+  const agents = [];
+  const files = fs4.readdirSync(agentsDir);
+  for (const file of files) {
+    if (!file.endsWith(".yaml") && !file.endsWith(".yml")) {
+      continue;
+    }
+    const filePath = path4.join(agentsDir, file);
+    try {
+      const content = fs4.readFileSync(filePath, "utf-8");
+      const parsed = yaml2.parse(content);
+      const stat = fs4.statSync(filePath);
+      const agent = {
+        id: parsed.id || path4.basename(file, path4.extname(file)),
+        name: parsed.name || void 0,
+        description: parsed.description || void 0,
+        model: parsed.model || void 0,
+        provider: parsed.provider || void 0,
+        createdAt: stat.birthtime.toISOString(),
+        updatedAt: stat.mtime.toISOString()
+      };
+      agents.push(agent);
+    } catch (error) {
+      continue;
+    }
+  }
+  return agents;
+}
+function listAgents(ctx) {
+  const agents = [];
+  const workspaceDir = getWorkspaceDir();
+  if (workspaceDir) {
+    const workspaceAgentsDir = path4.join(workspaceDir, "agents");
+    const workspaceAgents = readAgentsFromDir(workspaceAgentsDir, "workspace");
+    for (const agent of workspaceAgents) {
+      agents.push({ ...agent, source: "workspace" });
+    }
+  }
+  const globalAgentsDir = path4.join(getStateDir(), "agents");
+  const globalAgents = readAgentsFromDir(globalAgentsDir, "global");
+  for (const agent of globalAgents) {
+    if (!agents.find((a) => a.id === agent.id)) {
+      agents.push({ ...agent, source: "global" });
+    }
+  }
+  output(
+    ctx,
+    successResponse({ agents, count: agents.length }),
+    () => {
+      if (agents.length === 0) {
+        console.log(chalk4.gray("No agents found."));
+        console.log();
+        console.log("Create an agent with:");
+        console.log(chalk4.cyan("  viben agent create -n <agent-id>"));
+        return;
+      }
+      outputTable(
+        ctx,
+        ["ID", "Name", "Model", "Source"],
+        agents.map((a) => [
+          a.id,
+          a.name || chalk4.gray("(unnamed)"),
+          a.model || chalk4.gray("(default)"),
+          a.source
+        ])
+      );
+    }
+  );
+}
+
+// src/commands/agent/create.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+import * as yaml3 from "yaml";
+import chalk5 from "chalk";
+function getAgentsDir(scope) {
+  if (scope === "workspace") {
+    const workspaceDir = getWorkspaceDir();
+    if (!workspaceDir) {
+      throw new CliError(
+        'Not in a workspace. Use --global or run "viben init" first.',
+        "NO_WORKSPACE"
+      );
+    }
+    return path5.join(workspaceDir, "agents");
+  }
+  return path5.join(getStateDir(), "agents");
+}
+function validateAgentId(id) {
+  if (!id || id.trim() === "") {
+    throw new CliError("Agent ID cannot be empty", "INVALID_ID");
+  }
+  if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(id)) {
+    throw new CliError(
+      "Agent ID must start with a letter and contain only letters, numbers, underscores, and hyphens",
+      "INVALID_ID"
+    );
+  }
+  if (id.length > 64) {
+    throw new CliError("Agent ID must be 64 characters or less", "INVALID_ID");
+  }
+}
+function createAgent(ctx, options) {
+  const id = options.name;
+  validateAgentId(id);
+  const scope = resolveScope({
+    global: options.global,
+    workspace: options.workspace
+  });
+  const agentsDir = getAgentsDir(scope);
+  const agentPath = path5.join(agentsDir, `${id}.yaml`);
+  if (fs5.existsSync(agentPath)) {
+    throw new CliError(
+      `Agent "${id}" already exists`,
+      "AGENT_EXISTS"
+    );
+  }
+  if (!fs5.existsSync(agentsDir)) {
+    fs5.mkdirSync(agentsDir, { recursive: true });
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const agent = {
+    id,
+    name: options.description ? void 0 : id,
+    description: options.description,
+    model: options.model,
+    provider: options.provider,
+    createdAt: now,
+    updatedAt: now
+  };
+  const agentConfig = {
+    id: agent.id
+  };
+  if (agent.name) {
+    agentConfig.name = agent.name;
+  }
+  if (agent.description) {
+    agentConfig.description = agent.description;
+  }
+  if (agent.model) {
+    agentConfig.model = agent.model;
+  }
+  if (agent.provider) {
+    agentConfig.provider = agent.provider;
+  }
+  const content = yaml3.stringify(agentConfig, { indent: 2 });
+  fs5.writeFileSync(agentPath, content, "utf-8");
+  output(
+    ctx,
+    successResponse({
+      agent,
+      path: agentPath,
+      scope
+    }),
+    () => {
+      console.log(chalk5.green("OK") + ` Created agent "${chalk5.cyan(id)}"`);
+      console.log();
+      console.log("Agent file:", chalk5.gray(agentPath));
+      console.log();
+      console.log("Next steps:");
+      console.log(chalk5.cyan(`  viben agent show -n ${id}`) + " - View agent details");
+    }
+  );
+}
+
+// src/commands/agent/show.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+import * as yaml4 from "yaml";
+import chalk6 from "chalk";
+function findAgent(id) {
+  const workspaceDir = getWorkspaceDir();
+  if (workspaceDir) {
+    const workspaceAgentPath = path6.join(workspaceDir, "agents", `${id}.yaml`);
+    if (fs6.existsSync(workspaceAgentPath)) {
+      const content = fs6.readFileSync(workspaceAgentPath, "utf-8");
+      const parsed = yaml4.parse(content);
+      const stat = fs6.statSync(workspaceAgentPath);
+      return {
+        agent: {
+          id: parsed.id || id,
+          name: parsed.name,
+          description: parsed.description,
+          model: parsed.model,
+          provider: parsed.provider,
+          createdAt: stat.birthtime.toISOString(),
+          updatedAt: stat.mtime.toISOString()
+        },
+        path: workspaceAgentPath,
+        source: "workspace"
+      };
+    }
+  }
+  const globalAgentPath = path6.join(getStateDir(), "agents", `${id}.yaml`);
+  if (fs6.existsSync(globalAgentPath)) {
+    const content = fs6.readFileSync(globalAgentPath, "utf-8");
+    const parsed = yaml4.parse(content);
+    const stat = fs6.statSync(globalAgentPath);
+    return {
+      agent: {
+        id: parsed.id || id,
+        name: parsed.name,
+        description: parsed.description,
+        model: parsed.model,
+        provider: parsed.provider,
+        createdAt: stat.birthtime.toISOString(),
+        updatedAt: stat.mtime.toISOString()
+      },
+      path: globalAgentPath,
+      source: "global"
+    };
+  }
+  return null;
+}
+function showAgent(ctx, id) {
+  const result = findAgent(id);
+  if (!result) {
+    throw new CliError(
+      `Agent "${id}" not found`,
+      "AGENT_NOT_FOUND"
+    );
+  }
+  const { agent, path: agentPath, source } = result;
+  output(
+    ctx,
+    successResponse({
+      agent,
+      path: agentPath,
+      source
+    }),
+    () => {
+      console.log(chalk6.bold.underline(`Agent: ${agent.id}`));
+      console.log();
+      const printField = (label, value, defaultVal) => {
+        const displayValue = value || chalk6.gray(defaultVal || "(not set)");
+        console.log(`  ${chalk6.cyan(label.padEnd(12))} ${displayValue}`);
+      };
+      printField("Name", agent.name);
+      printField("Description", agent.description);
+      printField("Model", agent.model, "(default)");
+      printField("Provider", agent.provider, "(default)");
+      printField("Source", source);
+      console.log();
+      printField("Created", formatDate(agent.createdAt));
+      printField("Updated", formatDate(agent.updatedAt));
+      console.log();
+      console.log(chalk6.gray("Config file:"), agentPath);
+    }
+  );
+}
+
+// src/commands/agent/index.ts
+function registerAgentCommand(program) {
+  const agentCmd = program.command("agent").description("Manage agents");
+  agentCmd.command("list").description("List all agents").action(() => {
+    const ctx = {
+      json: program.opts().json || false,
+      verbose: program.opts().verbose || false,
+      quiet: program.opts().quiet || false
+    };
+    try {
+      listAgents(ctx);
+    } catch (error) {
+      if (error instanceof CliError) {
+        output(ctx, error.toResponse(), () => {
+          console.error(chalk7.red("Error:"), error.message);
+        });
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+  agentCmd.command("create").description("Create a new agent").requiredOption("-n, --name <id>", "Agent ID (required)").option("-d, --description <text>", "Agent description").option("-m, --model <model>", "Model to use").option("-p, --provider <provider>", "Provider name").option("-g, --global", "Create in global scope").option("-w, --workspace", "Create in workspace scope").action((options) => {
+    const ctx = {
+      json: program.opts().json || false,
+      verbose: program.opts().verbose || false,
+      quiet: program.opts().quiet || false
+    };
+    try {
+      if (!options.name) {
+        throw new CliError("Agent ID is required (-n, --name)", "MISSING_ID");
+      }
+      createAgent(ctx, {
+        name: options.name,
+        description: options.description,
+        model: options.model,
+        provider: options.provider,
+        global: options.global || program.opts().global,
+        workspace: options.workspace || program.opts().workspace
+      });
+    } catch (error) {
+      if (error instanceof CliError) {
+        output(ctx, error.toResponse(), () => {
+          console.error(chalk7.red("Error:"), error.message);
+        });
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+  agentCmd.command("show").description("Show agent details").requiredOption("-n, --name <id>", "Agent ID (required)").action((options) => {
+    const ctx = {
+      json: program.opts().json || false,
+      verbose: program.opts().verbose || false,
+      quiet: program.opts().quiet || false
+    };
+    try {
+      if (!options.name) {
+        throw new CliError("Agent ID is required (-n, --name)", "MISSING_ID");
+      }
+      showAgent(ctx, options.name);
+    } catch (error) {
+      if (error instanceof CliError) {
+        output(ctx, error.toResponse(), () => {
+          console.error(chalk7.red("Error:"), error.message);
+        });
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+}
+
+// src/cli.ts
+var require2 = createRequire(import.meta.url);
+var packageJson = require2("../package.json");
+function createProgram() {
+  const program = new Command();
+  program.name("viben").description("Viben CLI - Orchestrate AI agent clusters in your local workspace").version(packageJson.version, "-v, --version", "Display version number");
+  program.option("--json", "Output in JSON format for machine consumption").option("-g, --global", "Use global scope").option("-w, --workspace", "Use workspace scope").option("--verbose", "Enable verbose output").option("-q, --quiet", "Suppress non-essential output");
+  registerInitCommand(program);
+  registerConfigCommand(program);
+  registerAgentCommand(program);
+  return program;
+}
+async function run(args) {
+  const program = createProgram();
+  await program.parseAsync(args || process.argv);
+}
+export {
+  CliError,
+  createProgram,
+  run
+};
+//# sourceMappingURL=index.js.map