@delega-dev/cli 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Delega Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,109 @@
+```
+     ____       __
+    / __ \___  / /__  ____ _____ _
+   / / / / _ \/ / _ \/ __ `/ __ `/
+  / /_/ /  __/ /  __/ /_/ / /_/ /
+ /_____/\___/_/\___/\__, /\__,_/
+                   /____/
+  Task infrastructure for AI agents
+```
+
+# delega-cli
+
+CLI for the Delega task API. Manage tasks, agents, and delegations from your terminal.
+
+## Installation
+
+```bash
+npm install -g delega-cli
+```
+
+## Quick Start
+
+```bash
+# Authenticate with your API key
+delega login
+
+# Create a task
+delega tasks create "Review pull request #42" --priority 1
+
+# List your tasks
+delega tasks list
+
+# Complete a task
+delega tasks complete <task-id>
+```
+
+## Commands
+
+### Authentication
+
+```bash
+delega login          # Authenticate with your API key
+delega whoami         # Show current authenticated agent
+```
+
+### Tasks
+
+```bash
+delega tasks list                          # List tasks
+delega tasks list --completed              # Include completed tasks
+delega tasks list --limit 10               # Limit results
+delega tasks create "content"              # Create a task
+delega tasks create "content" --priority 1 # Create with priority (1-4)
+delega tasks create "content" --labels "bug,urgent"
+delega tasks create "content" --due "2026-03-15"
+delega tasks show <id>                     # Show task details
+delega tasks complete <id>                 # Mark task as completed
+delega tasks delete <id>                   # Delete a task
+delega tasks delegate <task-id> <agent-id> # Delegate to another agent
+delega tasks delegate <task-id> <agent-id> --content "subtask description"
+```
+
+### Agents
+
+```bash
+delega agents list                              # List agents
+delega agents create <name>                     # Create an agent
+delega agents create <name> --display-name "Friendly Name"
+delega agents rotate <id>                       # Rotate an agent's API key
+```
+
+### Stats
+
+```bash
+delega stats          # Show usage statistics
+```
+
+## Global Options
+
+```bash
+--json                # Output raw JSON for any command
+--api-url <url>       # Override API URL (for self-hosted instances)
+--version             # Show version
+--help                # Show help
+```
+
+## Configuration
+
+Config is stored in `~/.delega/config.json`:
+
+```json
+{
+  "api_key": "dlg_...",
+  "api_url": "https://api.delega.dev"
+}
+```
+
+## Environment Variables
+
+| Variable | Description |
+|---|---|
+| `DELEGA_API_KEY` | API key (overrides config file) |
+| `DELEGA_API_URL` | API base URL (overrides config file) |
+
+Environment variables take precedence over the config file.
+
+## License
+
+MIT

package/dist/api.d.ts

@@ -0,0 +1,5 @@
+export interface ApiError {
+    error?: string;
+    message?: string;
+}
+export declare function apiCall<T = unknown>(method: string, path: string, body?: unknown): Promise<T>;

package/dist/api.js

@@ -0,0 +1,45 @@
+import { getApiKey, getApiUrl } from "./config.js";
+export async function apiCall(method, path, body) {
+    const apiKey = getApiKey();
+    if (!apiKey) {
+        console.error("Not authenticated. Run: delega login");
+        process.exit(1);
+    }
+    const url = getApiUrl() + path;
+    const headers = {
+        "X-Agent-Key": apiKey,
+        "Content-Type": "application/json",
+    };
+    const options = { method, headers };
+    if (body !== undefined) {
+        options.body = JSON.stringify(body);
+    }
+    let res;
+    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;
+    const text = await res.text();
+    try {
+        data = text ? JSON.parse(text) : {};
+    }
+    catch {
+        data = { message: text };
+    }
+    if (!res.ok) {
+        const errData = data;
+        const msg = errData.error || errData.message || `Request failed (${res.status})`;
+        console.error(`Error: ${msg}`);
+        process.exit(1);
+    }
+    return data;
+}

package/dist/commands/agents.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const agentsCommand: Command;

package/dist/commands/agents.js

@@ -0,0 +1,86 @@
+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";
+function confirm(question) {
+    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("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, opts) => {
+    const body = { name };
+    if (opts.displayName)
+        body.display_name = opts.displayName;
+    const agent = await apiCall("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) => {
+    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("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/dist/commands/login.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const loginCommand: Command;

package/dist/commands/login.js

@@ -0,0 +1,66 @@
+import { Command } from "commander";
+import node_readline from "node:readline";
+import { saveConfig, loadConfig } from "../config.js";
+import { printBanner } from "../ui.js";
+async function prompt(question) {
+    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;
+    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());
+        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/dist/commands/stats.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const statsCommand: Command;

package/dist/commands/stats.js

@@ -0,0 +1,40 @@
+import { Command } from "commander";
+import { apiCall } from "../api.js";
+import { label } from "../ui.js";
+export const statsCommand = new Command("stats")
+    .description("Show usage statistics")
+    .option("--json", "Output raw JSON")
+    .action(async (opts) => {
+    const data = await apiCall("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/dist/commands/tasks.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const tasksCommand: Command;

package/dist/commands/tasks.js

@@ -0,0 +1,153 @@
+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";
+function confirm(question) {
+    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 = [];
+    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("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, opts) => {
+    const body = { content };
+    if (opts.priority)
+        body.priority = opts.priority;
+    if (opts.labels)
+        body.labels = opts.labels.split(",").map((l) => l.trim());
+    if (opts.due)
+        body.due_date = opts.due;
+    const task = await apiCall("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, opts) => {
+    const task = await apiCall("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) => {
+    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) => {
+    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, agentId, opts) => {
+    const body = { 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/dist/commands/whoami.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const whoamiCommand: Command;

package/dist/commands/whoami.js

@@ -0,0 +1,32 @@
+import { Command } from "commander";
+import { apiCall } from "../api.js";
+import { label } from "../ui.js";
+export const whoamiCommand = new Command("whoami")
+    .description("Show current authenticated agent")
+    .action(async () => {
+    const data = await apiCall("GET", "/v1/agents");
+    let 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();
+});

package/dist/config.d.ts

@@ -0,0 +1,8 @@
+export interface DelegaConfig {
+    api_key?: string;
+    api_url?: string;
+}
+export declare function loadConfig(): DelegaConfig;
+export declare function saveConfig(config: DelegaConfig): void;
+export declare function getApiKey(): string | undefined;
+export declare function getApiUrl(): string;

package/dist/config.js

@@ -0,0 +1,37 @@
+import node_fs from "node:fs";
+import node_path from "node:path";
+import node_os from "node:os";
+function getConfigDir() {
+    return node_path.join(node_os.homedir(), ".delega");
+}
+function getConfigPath() {
+    return node_path.join(getConfigDir(), "config.json");
+}
+export function loadConfig() {
+    const configPath = getConfigPath();
+    if (!node_fs.existsSync(configPath)) {
+        return {};
+    }
+    try {
+        const raw = node_fs.readFileSync(configPath, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+export function saveConfig(config) {
+    const configDir = getConfigDir();
+    if (!node_fs.existsSync(configDir)) {
+        node_fs.mkdirSync(configDir, { recursive: true });
+    }
+    node_fs.writeFileSync(getConfigPath(), JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+export function getApiKey() {
+    return process.env.DELEGA_API_KEY || loadConfig().api_key;
+}
+export function getApiUrl() {
+    return (process.env.DELEGA_API_URL ||
+        loadConfig().api_url ||
+        "https://api.delega.dev");
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { loginCommand } from "./commands/login.js";
+import { whoamiCommand } from "./commands/whoami.js";
+import { tasksCommand } from "./commands/tasks.js";
+import { agentsCommand } from "./commands/agents.js";
+import { statsCommand } from "./commands/stats.js";
+import { printBanner } from "./ui.js";
+const program = new Command();
+program
+    .name("delega")
+    .description("CLI for Delega task API")
+    .version("1.0.0")
+    .option("--api-url <url>", "Override API URL")
+    .hook("preAction", (thisCommand) => {
+    const apiUrl = thisCommand.opts().apiUrl;
+    if (apiUrl) {
+        process.env.DELEGA_API_URL = apiUrl;
+    }
+});
+program.addCommand(loginCommand);
+program.addCommand(whoamiCommand);
+program.addCommand(tasksCommand);
+program.addCommand(agentsCommand);
+program.addCommand(statsCommand);
+program.on("command:*", () => {
+    printBanner();
+    program.help();
+});
+if (process.argv.length <= 2) {
+    printBanner();
+    program.help();
+}
+program.parse();

package/dist/ui.d.ts

@@ -0,0 +1,7 @@
+export declare function printBanner(): void;
+export declare function printTable(headers: string[], rows: string[][]): void;
+export declare function formatDate(iso: string): string;
+export declare function formatId(id: string): string;
+export declare function priorityBadge(n: number): string;
+export declare function statusBadge(s: string): string;
+export declare function label(key: string, value: string): void;