@agent-api/cli 0.0.1

package/dist/tui/workbench.d.ts

@@ -0,0 +1,154 @@
+import type { LocalToolApprovalRequest, WorkdirAccessMode } from "../agent.js";
+export type WorkbenchRole = "user" | "assistant" | "system";
+export interface WorkbenchMessage {
+    id: string;
+    role: WorkbenchRole;
+    text: string;
+}
+export type ActivityLevel = "info" | "success" | "warning" | "error";
+export interface WorkbenchActivity {
+    id: string;
+    level: ActivityLevel;
+    text: string;
+    timestamp: number;
+}
+export interface WorkbenchWorkdirStatus {
+    root: string;
+    name: string;
+    fileCount: number;
+    totalBytes: number;
+    scanTruncated: boolean;
+}
+export interface LocalToolApproval extends LocalToolApprovalRequest {
+    id: string;
+    createdAt: number;
+}
+export interface WorkbenchState {
+    messages: WorkbenchMessage[];
+    activities: WorkbenchActivity[];
+    busy: boolean;
+    contextEnabled: boolean;
+    workdir: WorkbenchWorkdirStatus | null;
+    activeAssistantMessageId: string | null;
+    pendingLocalTool: LocalToolApproval | null;
+    accessMode: WorkdirAccessMode;
+    currentConversation: string;
+}
+export type WorkbenchAction = {
+    type: "message.add";
+    role: WorkbenchRole;
+    text: string;
+    id?: string;
+} | {
+    type: "message.append";
+    id: string;
+    delta: string;
+} | {
+    type: "messages.clear";
+} | {
+    type: "activity.add";
+    level?: ActivityLevel;
+    text: string;
+} | {
+    type: "busy.set";
+    busy: boolean;
+} | {
+    type: "context.toggle";
+} | {
+    type: "context.set";
+    enabled: boolean;
+} | {
+    type: "workdir.set";
+    workdir: WorkbenchWorkdirStatus;
+} | {
+    type: "assistant.active";
+    id: string | null;
+} | {
+    type: "local_tool.pending.set";
+    approval: LocalToolApprovalRequest;
+} | {
+    type: "local_tool.pending.clear";
+} | {
+    type: "access.set";
+    mode: WorkdirAccessMode;
+} | {
+    type: "conversation.set";
+    name: string;
+};
+export type WorkbenchCommand = {
+    kind: "invalid";
+    command: string;
+} | {
+    kind: "abort";
+} | {
+    kind: "quit";
+} | {
+    kind: "help";
+} | {
+    kind: "clear";
+} | {
+    kind: "login";
+} | {
+    kind: "logout";
+} | {
+    kind: "delete_profile";
+} | {
+    kind: "switch_profile";
+    name?: string;
+} | {
+    kind: "auth_status";
+} | {
+    kind: "config";
+    field?: "preset";
+    value?: string;
+} | {
+    kind: "context";
+    enabled?: boolean;
+} | {
+    kind: "workdir";
+    enabled?: boolean;
+} | {
+    kind: "access";
+    mode?: WorkdirAccessMode;
+} | {
+    kind: "preset";
+    value?: string;
+} | {
+    kind: "model";
+    value?: string;
+} | {
+    kind: "summary";
+} | {
+    kind: "search";
+    query: string;
+} | {
+    kind: "new_conversation";
+    name?: string;
+} | {
+    kind: "switch_conversation";
+    name: string;
+} | {
+    kind: "list_conversations";
+} | {
+    kind: "refresh_catalog";
+} | {
+    kind: "preview";
+} | {
+    kind: "apply";
+} | {
+    kind: "apply_all";
+} | {
+    kind: "reject";
+};
+export declare function createInitialWorkbenchState(options: {
+    contextEnabled: boolean;
+    accessMode?: WorkdirAccessMode;
+    conversation?: string;
+}): WorkbenchState;
+export declare function workbenchReducer(state: WorkbenchState, action: WorkbenchAction): WorkbenchState;
+export declare function parseWorkbenchCommand(input: string): WorkbenchCommand | null;
+export declare function parsePendingApprovalCommand(input: string): WorkbenchCommand | null;
+export declare function helpText(): string;
+export declare function workdirText(status: WorkbenchWorkdirStatus | null): string;
+export declare function formatBytes(bytes: number): string;
+export declare function activityColor(level: ActivityLevel): "green" | "yellow" | "red" | "gray";

package/dist/tui/workbench.js

@@ -0,0 +1,288 @@
+export function createInitialWorkbenchState(options) {
+    const accessMode = options.accessMode ?? (options.contextEnabled ? "approval" : "off");
+    return {
+        messages: [
+            newMessage("system", "Agent API Workbench is ready. Type /help for commands."),
+        ],
+        activities: [
+            newActivity("info", "Workbench started"),
+        ],
+        busy: false,
+        contextEnabled: options.contextEnabled || accessMode === "approval" || accessMode === "full",
+        workdir: null,
+        activeAssistantMessageId: null,
+        pendingLocalTool: null,
+        accessMode,
+        currentConversation: options.conversation || "default",
+    };
+}
+export function workbenchReducer(state, action) {
+    switch (action.type) {
+        case "message.add":
+            return {
+                ...state,
+                messages: [...state.messages, newMessage(action.role, action.text, action.id)],
+            };
+        case "message.append":
+            return {
+                ...state,
+                messages: state.messages.map((message) => message.id === action.id ? { ...message, text: message.text + action.delta } : message),
+            };
+        case "messages.clear":
+            return {
+                ...state,
+                messages: [newMessage("system", "Cleared. Type /help for commands.")],
+            };
+        case "activity.add":
+            return {
+                ...state,
+                activities: [...state.activities, newActivity(action.level ?? "info", action.text)].slice(-20),
+            };
+        case "busy.set":
+            return { ...state, busy: action.busy };
+        case "context.toggle":
+            return setLocalAccess(state, state.contextEnabled ? "off" : "approval");
+        case "context.set":
+            return setLocalAccess(state, action.enabled ? "approval" : "off");
+        case "workdir.set":
+            return {
+                ...state,
+                workdir: action.workdir,
+                activities: [...state.activities, newActivity("success", `Workdir loaded: ${action.workdir.name}`)].slice(-20),
+            };
+        case "assistant.active":
+            return { ...state, activeAssistantMessageId: action.id };
+        case "local_tool.pending.set": {
+            const pending = {
+                ...action.approval,
+                id: `local-${Date.now()}`,
+                createdAt: Date.now(),
+            };
+            return {
+                ...state,
+                pendingLocalTool: pending,
+                activities: [
+                    ...state.activities,
+                    newActivity("warning", `Local approval ready: ${pending.name}${pending.action ? `.${pending.action}` : ""}`),
+                ].slice(-20),
+            };
+        }
+        case "local_tool.pending.clear":
+            return {
+                ...state,
+                pendingLocalTool: null,
+            };
+        case "access.set":
+            return setLocalAccess(state, action.mode);
+        case "conversation.set":
+            return {
+                ...state,
+                currentConversation: action.name,
+                activities: [...state.activities, newActivity("info", `Conversation: ${action.name}`)].slice(-20),
+            };
+        default:
+            return state;
+    }
+}
+function setLocalAccess(state, mode) {
+    return {
+        ...state,
+        accessMode: mode,
+        contextEnabled: mode !== "off",
+        pendingLocalTool: mode === "off" ? null : state.pendingLocalTool,
+        activities: [...state.activities, newActivity(mode === "off" ? "warning" : "success", `Local access: ${mode}`)].slice(-20),
+    };
+}
+export function parseWorkbenchCommand(input) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith("/"))
+        return null;
+    const [name = "", ...rest] = trimmed.slice(1).split(/\s+/);
+    switch (name) {
+        case "abort":
+        case "cancel":
+            return { kind: "abort" };
+        case "quit":
+            return { kind: "quit" };
+        case "exit":
+            return { kind: "quit" };
+        case "help":
+            return { kind: "help" };
+        case "clear":
+            return { kind: "clear" };
+        case "login":
+        case "signin":
+            return { kind: "login" };
+        case "logout":
+        case "signout":
+            return { kind: "logout" };
+        case "delete-profile":
+        case "delete_profile":
+            return { kind: "delete_profile" };
+        case "switch-profile":
+        case "switch_profile":
+            return { kind: "switch_profile", name: rest.join(" ").trim() || undefined };
+        case "auth":
+            return { kind: "auth_status" };
+        case "config":
+        case "settings": {
+            const [field, ...valueParts] = rest;
+            if (!field)
+                return { kind: "config" };
+            if (field === "preset") {
+                return { kind: "config", field, value: valueParts.join(" ").trim() || undefined };
+            }
+            return { kind: "invalid", command: `${name} ${field}` };
+        }
+        case "context":
+            return { kind: "context", enabled: parseOnOff(rest[0]) };
+        case "access": {
+            const mode = rest[0];
+            if (mode === "off" || mode === "approval" || mode === "full")
+                return { kind: "access", mode };
+            return { kind: "access" };
+        }
+        case "preset": {
+            const value = rest.join(" ").trim();
+            return { kind: "preset", value: value || undefined };
+        }
+        case "model": {
+            const value = rest.join(" ").trim();
+            return { kind: "model", value: value || undefined };
+        }
+        case "workdir":
+        case "local":
+            return { kind: "workdir", enabled: parseOnOff(rest[0]) };
+        case "summary":
+            return { kind: "summary" };
+        case "new":
+        case "thread":
+            return { kind: "new_conversation", name: rest.join(" ").trim() || undefined };
+        case "conversation":
+        case "switch":
+        case "use":
+            if (rest.length === 0)
+                return { kind: "list_conversations" };
+            return { kind: "switch_conversation", name: rest.join(" ").trim() };
+        case "conversations":
+        case "threads":
+            return { kind: "list_conversations" };
+        case "refresh":
+        case "reload":
+        case "refresh-catalog":
+            return { kind: "refresh_catalog" };
+        case "search":
+        case "grep":
+            return { kind: "search", query: rest.join(" ").trim() };
+        case "preview":
+            return { kind: "preview" };
+        case "apply":
+            return { kind: "apply" };
+        case "apply-all":
+        case "yes-all":
+            return { kind: "apply_all" };
+        case "reject":
+            return { kind: "reject" };
+        default:
+            return { kind: "invalid", command: name };
+    }
+}
+export function parsePendingApprovalCommand(input) {
+    const trimmed = input.trim().toLowerCase();
+    if (!trimmed.startsWith("/"))
+        return null;
+    const [name = ""] = trimmed.slice(1).split(/\s+/);
+    switch (name) {
+        case "apply":
+        case "yes":
+            return { kind: "apply" };
+        case "apply-all":
+        case "yes-all":
+            return { kind: "apply_all" };
+        case "reject":
+        case "no":
+            return { kind: "reject" };
+        default:
+            return null;
+    }
+}
+export function helpText() {
+    return [
+        "Commands:",
+        "/auth            show current auth profile",
+        "/login           return to auth gate without deleting profiles",
+        "/logout          leave current session and return to auth gate",
+        "/switch-profile  switch/sign in with a different profile",
+        "/delete-profile  delete current saved profile and return to auth",
+        "/config          show current run configuration and saved defaults",
+        "/config preset   save default preset; use none/off for no preset, reset for built-in",
+        "/preset [name]   show or set preset; use none/off to clear",
+        "/model [name]    show or set explicit model; use auto/none/off to clear",
+        "/access [mode]   show or set local tool access: off, approval, or full",
+        "/workdir       show local workdir status",
+        "/workdir on    shortcut for /access approval; /workdir off hides local tools",
+        "/new [name]      start a fresh conversation in this workbench",
+        "/switch <name>   switch to an existing/new conversation handle",
+        "/conversations   list saved local conversation handles",
+        "/summary         show local workdir summary previews",
+        "/search <query>  search text in the local workdir",
+        "/preview         show pending local action preview",
+        "/apply           apply pending local action",
+        "/apply-all       apply pending action and allow future local actions",
+        "/reject          reject pending local action",
+        "/abort           cancel the in-flight agent turn",
+        "/context         toggle local context packaging for each agent turn",
+        "/clear           clear the visible terminal transcript",
+        "/quit            leave the workbench",
+    ].join("\n");
+}
+function parseOnOff(value) {
+    if (!value)
+        return undefined;
+    const normalized = value.toLowerCase();
+    if (["on", "enable", "enabled", "yes", "true"].includes(normalized))
+        return true;
+    if (["off", "disable", "disabled", "no", "false"].includes(normalized))
+        return false;
+    return undefined;
+}
+export function workdirText(status) {
+    if (!status)
+        return "Workdir summary is still loading.";
+    return [
+        `Workdir: ${status.root}`,
+        `Files: ${status.fileCount}`,
+        `Size: ${formatBytes(status.totalBytes)}`,
+        `Scan truncated: ${status.scanTruncated ? "yes" : "no"}`,
+    ].join("\n");
+}
+export function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
+}
+export function activityColor(level) {
+    if (level === "success")
+        return "green";
+    if (level === "warning")
+        return "yellow";
+    if (level === "error")
+        return "red";
+    return "gray";
+}
+function newMessage(role, text, id = randomId()) {
+    return { id, role, text };
+}
+function newActivity(level, text) {
+    return {
+        id: randomId(),
+        level,
+        text,
+        timestamp: Date.now(),
+    };
+}
+function randomId() {
+    return Math.random().toString(36).slice(2);
+}

package/dist/update.d.ts

@@ -0,0 +1,16 @@
+export interface UpdateCheckResult {
+    current: string;
+    latest: string;
+    packageName: string;
+    updateAvailable: boolean;
+}
+export interface UpdateCheckOptions {
+    currentVersion?: string;
+    packageName?: string;
+    registryURL?: string;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+export declare function checkForUpdate(options?: UpdateCheckOptions): Promise<UpdateCheckResult | null>;
+export declare function formatUpdateNotice(result: UpdateCheckResult): string;
+export declare function compareVersions(a: string, b: string): number;

package/dist/update.js

@@ -0,0 +1,74 @@
+import { cliVersion } from "./runtime/index.js";
+const defaultPackageName = "@agent-api/cli";
+const defaultRegistryURL = "https://registry.npmjs.org";
+export async function checkForUpdate(options = {}) {
+    const packageName = options.packageName || process.env.AGENT_TUI_UPDATE_PACKAGE || defaultPackageName;
+    const current = options.currentVersion || cliVersion;
+    const registryURL = (options.registryURL || process.env.AGENT_TUI_NPM_REGISTRY || defaultRegistryURL).replace(/\/+$/, "");
+    const timeoutMs = options.timeoutMs ?? 1500;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    const signal = combineSignals(options.signal, controller.signal);
+    try {
+        const response = await fetch(`${registryURL}/${encodeURIComponent(packageName).replace(/^%40/, "@")}/latest`, {
+            headers: { Accept: "application/json" },
+            signal,
+        });
+        if (!response.ok)
+            return null;
+        const payload = await response.json().catch(() => undefined);
+        const latest = typeof payload?.version === "string" ? payload.version : "";
+        if (!latest)
+            return null;
+        return {
+            current,
+            latest,
+            packageName,
+            updateAvailable: compareVersions(latest, current) > 0,
+        };
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function formatUpdateNotice(result) {
+    return `Update available: ${result.packageName} ${result.current} -> ${result.latest}. Run: npm install -g ${result.packageName}@latest`;
+}
+export function compareVersions(a, b) {
+    const left = parseVersion(a);
+    const right = parseVersion(b);
+    for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+        const delta = (left[index] ?? 0) - (right[index] ?? 0);
+        if (delta !== 0)
+            return delta > 0 ? 1 : -1;
+    }
+    return 0;
+}
+function parseVersion(version) {
+    return version
+        .replace(/^[^\d]*/, "")
+        .split(/[.-]/)
+        .slice(0, 3)
+        .map((part) => {
+        const parsed = Number.parseInt(part, 10);
+        return Number.isFinite(parsed) ? parsed : 0;
+    });
+}
+function combineSignals(...signals) {
+    const active = signals.filter((signal) => Boolean(signal));
+    if (active.length === 1)
+        return active[0];
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    for (const signal of active) {
+        if (signal.aborted) {
+            controller.abort();
+            break;
+        }
+        signal.addEventListener("abort", abort, { once: true });
+    }
+    return controller.signal;
+}

package/dist/workdir/index.d.ts

@@ -0,0 +1,22 @@
+import { type LocalContextManifest, type LocalSummary, type LocalWorkdir, type LocalWorkdirSnapshot } from "@agent-api/sdk/local";
+export interface WorkdirOptions {
+    path?: string;
+    name?: string;
+}
+export interface WorkdirContextOptions extends WorkdirOptions {
+    query?: string;
+    maxFiles?: number;
+    maxBytes?: number;
+    includeContent?: boolean;
+}
+export interface WorkdirService {
+    root: string;
+    name: string;
+    workdir: LocalWorkdir;
+    summarize(): Promise<LocalSummary>;
+    snapshot(): Promise<LocalWorkdirSnapshot>;
+    packageContext(options?: Omit<WorkdirContextOptions, "path" | "name">): Promise<LocalContextManifest>;
+    contextBlock(options?: Omit<WorkdirContextOptions, "path" | "name">): Promise<string>;
+}
+export declare function openWorkdir(options?: WorkdirOptions): Promise<WorkdirService>;
+export declare function buildWorkdirContextBlock(options: WorkdirContextOptions): Promise<string>;

package/dist/workdir/index.js

@@ -0,0 +1,46 @@
+import { createLocalContextPackage, } from "@agent-api/sdk/local";
+import { resolve } from "node:path";
+import { runtime } from "../runtime/index.js";
+export async function openWorkdir(options = {}) {
+    await runtime.ensure();
+    const root = resolve(options.path || process.cwd());
+    const name = options.name || root.split(/[\\/]/).filter(Boolean).at(-1) || "workdir";
+    const workdir = runtime.workdir(root, {
+        name,
+        trusted: true,
+        gitignore: true,
+    });
+    return {
+        root,
+        name,
+        workdir,
+        summarize: () => workdir.summarize(),
+        snapshot: () => workdir.snapshot({ hash: true }),
+        packageContext: (contextOptions = {}) => createLocalContextPackage(workdir, {
+            query: contextOptions.query,
+            includeSearch: Boolean(contextOptions.query),
+            maxFiles: contextOptions.maxFiles,
+            maxBytes: contextOptions.maxBytes,
+            includeContent: contextOptions.includeContent,
+        }),
+        contextBlock: async (contextOptions = {}) => {
+            const context = await createLocalContextPackage(workdir, {
+                query: contextOptions.query,
+                includeSearch: Boolean(contextOptions.query),
+                maxFiles: contextOptions.maxFiles,
+                maxBytes: contextOptions.maxBytes,
+                includeContent: contextOptions.includeContent,
+            });
+            return [
+                "Local workdir context follows. Use it as user-provided project context; do not assume files outside this manifest exist.",
+                "```json",
+                JSON.stringify(context, null, 2),
+                "```",
+            ].join("\n");
+        },
+    };
+}
+export async function buildWorkdirContextBlock(options) {
+    const service = await openWorkdir(options);
+    return service.contextBlock(options);
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@agent-api/cli",
+  "version": "0.0.1",
+  "description": "First-class command line interface for Agent API",
+  "license": "MIT",
+  "homepage": "https://github.com/scalebox-dev/agent-tui#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/scalebox-dev/agent-tui.git"
+  },
+  "bugs": {
+    "url": "https://github.com/scalebox-dev/agent-tui/issues"
+  },
+  "type": "module",
+  "bin": {
+    "agent-api": "dist/index.js",
+    "agentsway": "dist/index.js",
+    "agent-tui": "dist/index.js"
+  },
+  "scripts": {
+    "sync-version": "node scripts/sync-version.mjs",
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "npm run clean && tsc -p tsconfig.json",
+    "dev": "npm run build && node dist/index.js",
+    "dev:link": "node scripts/dev-link.mjs",
+    "start": "node dist/index.js",
+    "smoke": "node dist/index.js --version && node dist/index.js --help",
+    "pack:local": "npm pack --pack-destination ./artifacts",
+    "release:local": "node scripts/release-local.mjs",
+    "prepack": "npm run sync-version && npm run build",
+    "test": "npm run sync-version && npm run build && node --test test/*.test.mjs"
+  },
+  "dependencies": {
+    "@agent-api/sdk": "^1.2.2",
+    "commander": "^14.0.3",
+    "ink": "^6.8.0",
+    "react": "^19.2.7",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "@types/react": "^19.2.17",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "files": [
+    "dist",
+    "README.md",
+    "package.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}