@delega-dev/cli 1.0.1

package/dist/ui.js

@@ -0,0 +1,79 @@
+import chalk from "chalk";
+const BANNER = `
+     ____       __
+    / __ \\___  / /__  ____ _____ _
+   / / / / _ \\/ / _ \\/ __ \`/ __ \`/
+  / /_/ /  __/ /  __/ /_/ / /_/ /
+ /_____/\\___/_/\\___/\\__, /\\__,_/
+                   /____/
+  Task infrastructure for AI agents
+`;
+export function printBanner() {
+    console.log(chalk.cyan(BANNER));
+}
+export function printTable(headers, rows) {
+    if (rows.length === 0)
+        return;
+    const colWidths = headers.map((h, i) => {
+        const maxRow = rows.reduce((max, row) => Math.max(max, (row[i] || "").length), 0);
+        return Math.max(h.length, maxRow);
+    });
+    const headerLine = headers
+        .map((h, i) => h.padEnd(colWidths[i]))
+        .join("  ");
+    console.log(chalk.cyan.bold(headerLine));
+    const separator = colWidths.map((w) => "─".repeat(w)).join("──");
+    console.log(chalk.dim(separator));
+    for (const row of rows) {
+        const line = row
+            .map((cell, i) => (cell || "").padEnd(colWidths[i]))
+            .join("  ");
+        console.log(line);
+    }
+}
+export function formatDate(iso) {
+    if (!iso)
+        return "—";
+    const d = new Date(iso);
+    return d.toLocaleDateString("en-US", {
+        month: "short",
+        day: "numeric",
+        year: "numeric",
+    });
+}
+export function formatId(id) {
+    return id.slice(0, 8);
+}
+export function priorityBadge(n) {
+    switch (n) {
+        case 1:
+            return chalk.red.bold("P1");
+        case 2:
+            return chalk.yellow.bold("P2");
+        case 3:
+            return chalk.green("P3");
+        case 4:
+            return chalk.dim("P4");
+        default:
+            return chalk.dim(`P${n}`);
+    }
+}
+export function statusBadge(s) {
+    switch (s?.toLowerCase()) {
+        case "completed":
+            return chalk.green("completed");
+        case "in_progress":
+        case "in progress":
+            return chalk.yellow("in_progress");
+        case "pending":
+            return chalk.blue("pending");
+        case "cancelled":
+        case "canceled":
+            return chalk.dim("cancelled");
+        default:
+            return s || "—";
+    }
+}
+export function label(key, value) {
+    console.log(`${chalk.cyan.bold(key + ":")} ${value}`);
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@delega-dev/cli",
+  "version": "1.0.1",
+  "description": "CLI for Delega task API",
+  "type": "module",
+  "bin": {
+    "delega": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node --esm src/index.ts"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "typescript": "^5.5.0"
+  },
+  "license": "MIT",
+  "author": "Delega <hello@delega.dev>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/delega-dev/delega-cli"
+  },
+  "keywords": [
+    "delega",
+    "ai-agents",
+    "task-management",
+    "mcp",
+    "cli",
+    "delegation",
+    "agent-infrastructure"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/api.ts

@@ -0,0 +1,61 @@
+import { getApiKey, getApiUrl } from "./config.js";
+
+export interface ApiError {
+  error?: string;
+  message?: string;
+}
+
+export async function apiCall<T = unknown>(
+  method: string,
+  path: string,
+  body?: unknown,
+): Promise<T> {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    console.error("Not authenticated. Run: delega login");
+    process.exit(1);
+  }
+
+  const url = getApiUrl() + path;
+
+  const headers: Record<string, string> = {
+    "X-Agent-Key": apiKey,
+    "Content-Type": "application/json",
+  };
+
+  const options: RequestInit = { method, headers };
+  if (body !== undefined) {
+    options.body = JSON.stringify(body);
+  }
+
+  let res: Response;
+  try {
+    res = await fetch(url, options);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`Connection error: ${msg}`);
+    process.exit(1);
+  }
+
+  if (res.status === 401) {
+    console.error("Authentication failed. Run: delega login");
+    process.exit(1);
+  }
+
+  let data: unknown;
+  const text = await res.text();
+  try {
+    data = text ? JSON.parse(text) : {};
+  } catch {
+    data = { message: text };
+  }
+
+  if (!res.ok) {
+    const errData = data as ApiError;
+    const msg = errData.error || errData.message || `Request failed (${res.status})`;
+    console.error(`Error: ${msg}`);
+    process.exit(1);
+  }
+
+  return data as T;
+}

package/src/commands/agents.ts

@@ -0,0 +1,115 @@
+import { Command } from "commander";
+import node_readline from "node:readline";
+import chalk from "chalk";
+import { apiCall } from "../api.js";
+import { printTable, formatDate, label } from "../ui.js";
+
+interface Agent {
+  id: string;
+  name: string;
+  display_name?: string;
+  active?: boolean;
+  created_at?: string;
+  api_key?: string;
+}
+
+function confirm(question: string): Promise<boolean> {
+  const rl = node_readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === "y");
+    });
+  });
+}
+
+const agentsList = new Command("list")
+  .description("List agents")
+  .option("--json", "Output raw JSON")
+  .action(async (opts) => {
+    const data = await apiCall<Agent[]>("GET", "/v1/agents");
+
+    if (opts.json) {
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+
+    const agents = Array.isArray(data) ? data : [data];
+
+    if (agents.length === 0) {
+      console.log("No agents found.");
+      return;
+    }
+
+    const headers = ["Name", "Display Name", "Active", "Created"];
+    const rows = agents.map((a) => [
+      a.name,
+      a.display_name || "—",
+      a.active !== false ? "yes" : "no",
+      formatDate(a.created_at || ""),
+    ]);
+
+    printTable(headers, rows);
+  });
+
+const agentsCreate = new Command("create")
+  .description("Create a new agent")
+  .argument("<name>", "Agent name")
+  .option("--display-name <name>", "Friendly display name")
+  .option("--json", "Output raw JSON")
+  .action(async (name: string, opts) => {
+    const body: Record<string, unknown> = { name };
+    if (opts.displayName) body.display_name = opts.displayName;
+
+    const agent = await apiCall<Agent>("POST", "/v1/agents", body);
+
+    if (opts.json) {
+      console.log(JSON.stringify(agent, null, 2));
+      return;
+    }
+
+    console.log();
+    label("Agent Created", agent.name);
+    if (agent.display_name) label("Display Name", agent.display_name);
+    label("ID", agent.id);
+    if (agent.api_key) {
+      console.log();
+      console.log(`  API Key: ${chalk.cyan.bold(agent.api_key)}`);
+      console.log(
+        chalk.yellow("  Save this key — it will not be shown again."),
+      );
+    }
+    console.log();
+  });
+
+const agentsRotate = new Command("rotate")
+  .description("Rotate an agent's API key")
+  .argument("<id>", "Agent ID")
+  .action(async (id: string) => {
+    const yes = await confirm(
+      `Rotate key for agent ${id}? Old key will stop working immediately. (y/N) `,
+    );
+    if (!yes) {
+      console.log("Cancelled.");
+      return;
+    }
+
+    const result = await apiCall<{ api_key: string }>(
+      "POST",
+      `/v1/agents/${id}/rotate-key`,
+    );
+
+    console.log();
+    console.log(`  New API Key: ${chalk.cyan.bold(result.api_key)}`);
+    console.log(chalk.yellow("  Save this key — it will not be shown again."));
+    console.log();
+  });
+
+export const agentsCommand = new Command("agents")
+  .description("Manage agents")
+  .addCommand(agentsList)
+  .addCommand(agentsCreate)
+  .addCommand(agentsRotate);

package/src/commands/login.ts

@@ -0,0 +1,79 @@
+import { Command } from "commander";
+import node_readline from "node:readline";
+import { saveConfig, loadConfig } from "../config.js";
+import { printBanner } from "../ui.js";
+
+interface Agent {
+  id: string;
+  name: string;
+  display_name?: string;
+}
+
+async function prompt(question: string): Promise<string> {
+  const rl = node_readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+export const loginCommand = new Command("login")
+  .description("Authenticate with the Delega API")
+  .action(async () => {
+    printBanner();
+
+    const key = await prompt("Enter your API key (starts with dlg_): ");
+
+    if (!key) {
+      console.error("No key provided.");
+      process.exit(1);
+    }
+
+    if (!key.startsWith("dlg_")) {
+      console.error("Invalid key format. Keys start with dlg_");
+      process.exit(1);
+    }
+
+    // Validate by calling the API
+    const config = loadConfig();
+    const apiUrl = config.api_url || process.env.DELEGA_API_URL || "https://api.delega.dev";
+
+    let res: Response;
+    try {
+      res = await fetch(`${apiUrl}/v1/agents`, {
+        headers: {
+          "X-Agent-Key": key,
+          "Content-Type": "application/json",
+        },
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`Connection error: ${msg}`);
+      process.exit(1);
+    }
+
+    if (!res.ok) {
+      console.error("Invalid API key. Authentication failed.");
+      process.exit(1);
+    }
+
+    let agentName = "agent";
+    try {
+      const data = (await res.json()) as Agent | Agent[];
+      if (Array.isArray(data) && data.length > 0) {
+        agentName = data[0].display_name || data[0].name;
+      } else if (!Array.isArray(data) && data.name) {
+        agentName = data.display_name || data.name;
+      }
+    } catch {
+      // Proceed with default name
+    }
+
+    saveConfig({ ...config, api_key: key });
+    console.log(`\nLogged in as ${agentName}. Key saved to ~/.delega/config.json`);
+  });

package/src/commands/stats.ts

@@ -0,0 +1,48 @@
+import { Command } from "commander";
+import { apiCall } from "../api.js";
+import { label } from "../ui.js";
+
+interface Stats {
+  total_tasks?: number;
+  completed_tasks?: number;
+  pending_tasks?: number;
+  total_agents?: number;
+  active_agents?: number;
+  [key: string]: unknown;
+}
+
+export const statsCommand = new Command("stats")
+  .description("Show usage statistics")
+  .option("--json", "Output raw JSON")
+  .action(async (opts) => {
+    const data = await apiCall<Stats>("GET", "/v1/stats");
+
+    if (opts.json) {
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+
+    console.log();
+    if (data.total_tasks !== undefined) label("Total Tasks", String(data.total_tasks));
+    if (data.completed_tasks !== undefined) label("Completed", String(data.completed_tasks));
+    if (data.pending_tasks !== undefined) label("Pending", String(data.pending_tasks));
+    if (data.total_agents !== undefined) label("Total Agents", String(data.total_agents));
+    if (data.active_agents !== undefined) label("Active Agents", String(data.active_agents));
+
+    // Print any additional stats fields
+    const knownKeys = new Set([
+      "total_tasks",
+      "completed_tasks",
+      "pending_tasks",
+      "total_agents",
+      "active_agents",
+    ]);
+    for (const [key, value] of Object.entries(data)) {
+      if (!knownKeys.has(key) && value !== undefined) {
+        const displayKey = key.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+        const displayVal = typeof value === "object" ? JSON.stringify(value) : String(value);
+        label(displayKey, displayVal);
+      }
+    }
+    console.log();
+  });

package/src/commands/tasks.ts

@@ -0,0 +1,189 @@
+import { Command } from "commander";
+import node_readline from "node:readline";
+import { apiCall } from "../api.js";
+import {
+  printTable,
+  formatDate,
+  formatId,
+  priorityBadge,
+  statusBadge,
+  label,
+} from "../ui.js";
+
+interface Task {
+  id: string;
+  content: string;
+  status: string;
+  priority: number;
+  labels?: string[];
+  due_date?: string;
+  created_at?: string;
+  updated_at?: string;
+  completed_at?: string;
+  assigned_to_agent_id?: string;
+  comments?: Comment[];
+}
+
+interface Comment {
+  id: string;
+  content: string;
+  created_at?: string;
+}
+
+function confirm(question: string): Promise<boolean> {
+  const rl = node_readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === "y");
+    });
+  });
+}
+
+const tasksList = new Command("list")
+  .description("List tasks")
+  .option("--completed", "Include completed tasks")
+  .option("--limit <n>", "Limit results", parseInt)
+  .option("--json", "Output raw JSON")
+  .action(async (opts) => {
+    let path = "/v1/tasks";
+    const params: string[] = [];
+    if (opts.completed) params.push("completed=true");
+    if (opts.limit) params.push(`limit=${opts.limit}`);
+    if (params.length > 0) path += "?" + params.join("&");
+
+    const data = await apiCall<Task[]>("GET", path);
+
+    if (opts.json) {
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+
+    const tasks = Array.isArray(data) ? data : [];
+
+    if (tasks.length === 0) {
+      console.log("No tasks found.");
+      return;
+    }
+
+    const headers = ["ID", "Priority", "Status", "Content"];
+    const rows = tasks.map((t) => [
+      formatId(t.id),
+      priorityBadge(t.priority),
+      statusBadge(t.status),
+      t.content.length > 50 ? t.content.slice(0, 47) + "..." : t.content,
+    ]);
+
+    printTable(headers, rows);
+  });
+
+const tasksCreate = new Command("create")
+  .description("Create a new task")
+  .argument("<content>", "Task content")
+  .option("--priority <n>", "Priority 1-4 (default: 1)", parseInt, 1)
+  .option("--labels <labels>", "Comma-separated labels")
+  .option("--due <date>", "Due date (YYYY-MM-DD)")
+  .option("--json", "Output raw JSON")
+  .action(async (content: string, opts) => {
+    const body: Record<string, unknown> = { content };
+    if (opts.priority) body.priority = opts.priority;
+    if (opts.labels) body.labels = opts.labels.split(",").map((l: string) => l.trim());
+    if (opts.due) body.due_date = opts.due;
+
+    const task = await apiCall<Task>("POST", "/v1/tasks", body);
+
+    if (opts.json) {
+      console.log(JSON.stringify(task, null, 2));
+      return;
+    }
+
+    console.log(`Task created: ${task.id}`);
+    console.log();
+    label("Content", task.content);
+    label("Priority", priorityBadge(task.priority));
+    label("Status", statusBadge(task.status));
+    if (task.due_date) label("Due", formatDate(task.due_date));
+  });
+
+const tasksShow = new Command("show")
+  .description("Show task details")
+  .argument("<id>", "Task ID")
+  .option("--json", "Output raw JSON")
+  .action(async (id: string, opts) => {
+    const task = await apiCall<Task>("GET", `/v1/tasks/${id}`);
+
+    if (opts.json) {
+      console.log(JSON.stringify(task, null, 2));
+      return;
+    }
+
+    console.log();
+    label("ID", task.id);
+    label("Content", task.content);
+    label("Status", statusBadge(task.status));
+    label("Priority", priorityBadge(task.priority));
+    const labels = typeof task.labels === "string" ? JSON.parse(task.labels) : task.labels;
+    if (labels && labels.length > 0) {
+      label("Labels", labels.join(", "));
+    }
+    if (task.due_date) label("Due", formatDate(task.due_date));
+    if (task.assigned_to_agent_id) label("Assigned To", task.assigned_to_agent_id);
+    label("Created", formatDate(task.created_at || ""));
+    if (task.updated_at) label("Updated", formatDate(task.updated_at));
+    if (task.completed_at) label("Completed", formatDate(task.completed_at));
+
+    if (task.comments && task.comments.length > 0) {
+      console.log();
+      console.log("Comments:");
+      for (const c of task.comments) {
+        console.log(`  [${formatDate(c.created_at || "")}] ${c.content}`);
+      }
+    }
+    console.log();
+  });
+
+const tasksComplete = new Command("complete")
+  .description("Mark a task as completed")
+  .argument("<id>", "Task ID")
+  .action(async (id: string) => {
+    await apiCall("POST", `/v1/tasks/${id}/complete`);
+    console.log(`Task ${id} completed.`);
+  });
+
+const tasksDelete = new Command("delete")
+  .description("Delete a task")
+  .argument("<id>", "Task ID")
+  .action(async (id: string) => {
+    const yes = await confirm(`Delete task ${id}? (y/N) `);
+    if (!yes) {
+      console.log("Cancelled.");
+      return;
+    }
+    await apiCall("DELETE", `/v1/tasks/${id}`);
+    console.log(`Task ${id} deleted.`);
+  });
+
+const tasksDelegate = new Command("delegate")
+  .description("Delegate a task to another agent")
+  .argument("<task_id>", "Task ID")
+  .argument("<agent_id>", "Agent ID to delegate to")
+  .requiredOption("--content <content>", "Subtask description (required)")
+  .action(async (taskId: string, agentId: string, opts) => {
+    const body: Record<string, unknown> = { assigned_to_agent_id: agentId };
+    if (opts.content) body.content = opts.content;
+
+    await apiCall("POST", `/v1/tasks/${taskId}/delegate`, body);
+    console.log(`Task delegated to ${agentId}.`);
+  });
+
+export const tasksCommand = new Command("tasks")
+  .description("Manage tasks")
+  .addCommand(tasksList)
+  .addCommand(tasksCreate)
+  .addCommand(tasksShow)
+  .addCommand(tasksComplete)
+  .addCommand(tasksDelete)
+  .addCommand(tasksDelegate);

package/src/commands/whoami.ts

@@ -0,0 +1,47 @@
+import { Command } from "commander";
+import { apiCall } from "../api.js";
+import { label } from "../ui.js";
+
+interface Agent {
+  id: string;
+  name: string;
+  display_name?: string;
+  email?: string;
+  plan?: string;
+  active?: boolean;
+  user?: {
+    email?: string;
+    plan?: string;
+  };
+}
+
+export const whoamiCommand = new Command("whoami")
+  .description("Show current authenticated agent")
+  .action(async () => {
+    const data = await apiCall<Agent | Agent[]>("GET", "/v1/agents");
+
+    let agent: Agent;
+    if (Array.isArray(data)) {
+      if (data.length === 0) {
+        console.error("No agent found.");
+        process.exit(1);
+      }
+      agent = data[0];
+    } else {
+      agent = data;
+    }
+
+    console.log();
+    label("Agent", agent.name);
+    if (agent.display_name) {
+      label("Display Name", agent.display_name);
+    }
+    if (agent.user?.email || agent.email) {
+      label("Email", agent.user?.email || agent.email || "");
+    }
+    if (agent.user?.plan || agent.plan) {
+      label("Plan", agent.user?.plan || agent.plan || "");
+    }
+    label("Active", agent.active !== false ? "yes" : "no");
+    console.log();
+  });