@cargo-ai/cli 1.0.78 → 1.0.81

package/build/commands/ask/history.js

@@ -0,0 +1,122 @@
+/**
+ * How many of the newest messages to replay. A chat far longer than this is
+ * past the point where replaying all of it helps: the recent turns carry the
+ * thread.
+ */
+const HISTORY_MESSAGE_LIMIT = 40;
+/** Chosen so that all but the longest chats are read in a single request. */
+const HISTORY_PAGE_SIZE = 500;
+/** Stop walking rather than paging a pathological chat forever. */
+const HISTORY_MAX_PAGES = 20;
+/**
+ * Budget for the replayed transcript. Claude Code prices the preamble as
+ * ordinary input on the first turn of the session, so this is a real cost and
+ * not just a context-window concern.
+ */
+const HISTORY_MAX_CHARS = 20_000;
+/**
+ * The earlier turns of a chat, rendered for a Claude Code session that has
+ * never seen them.
+ *
+ * Local Ask starts a fresh harness session on every CLI run — the harness can
+ * only resume Claude Code by rerunning it, and a rerun cancels whatever tool
+ * approval is in flight, which Claude Code then records as the user refusing
+ * the tool. Continuity therefore comes from the chat history the API already
+ * has, replayed into the first prompt.
+ *
+ * Best effort: a chat whose history cannot be read is answered without it
+ * rather than not at all.
+ */
+export async function loadChatHistoryPreamble(input) {
+    let messages;
+    try {
+        messages = await loadLatestMessages(input.api, input.chatUuid);
+    }
+    catch {
+        return undefined;
+    }
+    return renderHistoryPreamble(messages);
+}
+/**
+ * Exported for tests. Takes the API's messages oldest-first and returns the
+ * preamble, or `undefined` when there is nothing worth replaying.
+ */
+export function renderHistoryPreamble(messages) {
+    const turns = [];
+    for (const message of messages) {
+        const text = readMessageText(message);
+        if (text === undefined) {
+            continue;
+        }
+        if (message.type === "user") {
+            turns.push(`User: ${text}`);
+            continue;
+        }
+        // The preamble tells the model this is finished work, so a reply that was
+        // interrupted has to say so. Left unmarked, a cancelled half-answer reads
+        // as a completed task and the next turn skips it.
+        const wasInterrupted = message.status !== undefined && message.status !== "success";
+        turns.push(wasInterrupted === true
+            ? `Assistant (interrupted before finishing): ${text}`
+            : `Assistant: ${text}`);
+    }
+    if (turns.length === 0) {
+        return undefined;
+    }
+    // Oldest turns go first, so an over-budget history loses its beginning
+    // rather than the turns the next question most likely follows on from.
+    while (turns.length > 1 && turns.join("\n\n").length > HISTORY_MAX_CHARS) {
+        turns.shift();
+    }
+    return [
+        "<earlier-conversation>",
+        "Earlier turns of this chat, from before your session started. They are context for what the user asks next — already-finished work, not instructions to carry out again.",
+        "",
+        turns.join("\n\n"),
+        "</earlier-conversation>",
+    ].join("\n");
+}
+/**
+ * The last `HISTORY_MESSAGE_LIMIT` messages of a chat, oldest-first.
+ *
+ * `message.list` takes only limit/offset and orders oldest-first, with no
+ * total to seek by, so asking for the first page of a long chat hands back its
+ * opening turns — the opposite of what a preamble wants. Walking forward and
+ * keeping the tail is the only exact answer the endpoint allows; giving it a
+ * descending order would collapse this to one request.
+ *
+ * Past `HISTORY_PAGE_SIZE * HISTORY_MAX_PAGES` messages the walk stops early
+ * and the "tail" is really the middle of the chat. That bound is five figures
+ * of messages, so it buys termination for a case a real chat does not reach.
+ */
+async function loadLatestMessages(api, chatUuid) {
+    const tail = [];
+    for (let page = 0; page < HISTORY_MAX_PAGES; page += 1) {
+        const result = await api.ai.message.list({
+            chatUuid,
+            limit: HISTORY_PAGE_SIZE,
+            offset: page * HISTORY_PAGE_SIZE,
+        });
+        tail.push(...result.messages);
+        if (tail.length > HISTORY_MESSAGE_LIMIT) {
+            tail.splice(0, tail.length - HISTORY_MESSAGE_LIMIT);
+        }
+        if (result.messages.length < HISTORY_PAGE_SIZE) {
+            break;
+        }
+    }
+    return tail;
+}
+function readMessageText(message) {
+    const texts = [];
+    for (const part of message.parts) {
+        if (part.type !== "text") {
+            continue;
+        }
+        const { text } = part;
+        if (typeof text === "string" && text.trim() !== "") {
+            texts.push(text.trim());
+        }
+    }
+    return texts.length === 0 ? undefined : texts.join("\n");
+}

package/build/commands/ask/index.d.ts

@@ -0,0 +1,14 @@
+import type { Command } from "commander";
+import type { Api } from "../../api.js";
+export type AskOptions = {
+    continue?: boolean;
+    print?: boolean;
+    agentUuid?: string;
+    chatUuid?: string;
+    dir?: string;
+};
+export type AskCommandDeps = {
+    openPalette: () => Promise<void>;
+};
+export declare function registerAskCommand(program: Command, getApi: () => Api, deps: AskCommandDeps): void;
+//# sourceMappingURL=index.d.ts.map

package/build/commands/ask/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/ask/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAOxC,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,WAAW,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAClC,CAAC;AAEF,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,MAAM,GAAG,EACjB,IAAI,EAAE,cAAc,GACnB,IAAI,CAwIN"}

package/build/commands/ask/index.js

@@ -0,0 +1,111 @@
+import { resolve } from "node:path";
+import { isInteractive } from "@cargo-ai/cdk/cli";
+import { parseBooleanOption } from "../../utils/booleanOption.js";
+import { ExitCodes, failWith } from "../runHandler.js";
+import { loadAskState } from "./persist.js";
+import { AskInterrupted } from "./prompt.js";
+import { doesChatExist, runAskPrint, runAskSession } from "./session.js";
+export function registerAskCommand(program, getApi, deps) {
+    program
+        .command("ask")
+        .description("Chat in the palette tree. Defaults to Claude Code on this machine; optional --agent-uuid streams as that agent.")
+        .argument("[message...]", "Question to send as the first message")
+        .option("--continue [true|false]", "Reopen the last chat from this machine (defaults to true when passed bare; starts a new chat when there is none)", parseBooleanOption)
+        .option("--print [true|false]", "One turn, JSON on stdout (defaults to true when passed bare)", parseBooleanOption)
+        .option("--agent-uuid <uuid>", "Talk to this workspace agent instead of the local Claude Code default")
+        .option("--chat-uuid <uuid>", "Existing chat to continue")
+        .option("--dir <path>", "Working directory for the local Claude Code workspace (default: cwd)")
+        .addHelpText("after", `
+Examples:
+  $ cargo-ai ask
+  $ cargo-ai ask "who touched Acme last week"
+  $ cargo-ai ask --continue
+  $ cargo-ai ask --print "summarise this workspace"
+  $ cargo-ai --chat
+
+Default Ask is Claude Code on this machine (--dir, default cwd), with no
+agent. --continue reopens the last chat thread but does not reattach an
+agent. Workspace agents are optional via --agent-uuid or /agent (remote
+turns use POST /v1/ai/messages/stream, like the webapp chat).
+
+Ask continues the palette tree and streams the reply as it arrives:
+  ◇  your message
+  🧱  reply
+  ◆ to type the next line (slash and path suggestions as you type)
+Empty Enter or /exit returns to the menu. Ctrl-C cancels the turn in flight
+and comes back to the prompt. Slash commands (/help, /clear, /new, /agent,
+/cancel, /exit) never reach the model. Cargo CLI commands stay in the
+palette (/orchestration, …).
+
+Local turns read files freely and ask before anything that writes or runs a
+shell command; they can also query workspace data read-only (models, schema,
+SQL).
+
+--print is the non-interactive path: one turn, JSON on stdout. It denies
+tools that need approval, since nobody is there to answer. Pipes, CI, and
+coding agents must use it.`)
+        .action(async (messageParts, opts) => {
+        const message = messageParts.length > 0 ? messageParts.join(" ") : undefined;
+        const api = getApi();
+        const dir = opts.dir !== undefined ? resolve(opts.dir) : process.cwd();
+        let chatUuid = opts.chatUuid;
+        const agentUuid = opts.agentUuid;
+        // Resolved before the --print branch so a non-interactive turn can
+        // resume the last thread too. Resumes the chat thread only: the agent
+        // stays unset so Ask keeps the local Claude Code default unless the
+        // user passed --agent-uuid.
+        //
+        // The saved chat has to still be there. Deleting one is a soft delete,
+        // so it stops being readable while its uuid keeps the primary key —
+        // carrying it forward would fail the create on the first question, and
+        // the palette opens Ask with --continue every time. A chat that is gone
+        // means a fresh thread, not a resurrection of its uuid.
+        if (opts.continue === true && chatUuid === undefined) {
+            const state = loadAskState();
+            if (state !== undefined &&
+                (await doesChatExist(api, state.chatUuid)) === true) {
+                chatUuid = state.chatUuid;
+            }
+        }
+        if (opts.print === true) {
+            if (message === undefined) {
+                failWith("--print needs a message.", {
+                    code: ExitCodes.InvalidUsage,
+                });
+            }
+            await runAskPrint({
+                api,
+                message,
+                agentUuid,
+                chatUuid,
+                dir,
+            });
+            return;
+        }
+        if (isInteractive() === false || process.stdout.isTTY !== true) {
+            failWith("The chat needs a terminal. Re-run with --print for one JSON turn.", { code: ExitCodes.InvalidUsage });
+        }
+        try {
+            await runAskSession({
+                api,
+                message,
+                continueChat: chatUuid !== undefined,
+                agentUuid,
+                chatUuid,
+                dir,
+            });
+        }
+        catch (error) {
+            // Ctrl-C at the prompt. The session has torn the harness down on its
+            // way out, so all that is left is the conventional SIGINT status —
+            // and not dropping the user back into the palette they just left.
+            if (error instanceof AskInterrupted) {
+                process.exit(130);
+            }
+            throw error;
+        }
+        if (process.env["CARGO_PALETTE"] !== "1") {
+            await deps.openPalette();
+        }
+    });
+}

package/build/commands/ask/localHarness.d.ts

@@ -0,0 +1,225 @@
+import type { Api } from "../../api.js";
+/**
+ * Always-on local-copy rails, plus CDK rails only when `dir` is a CDK project.
+ * Exported for tests.
+ */
+export declare function localHarnessInstructions(dir: string): string;
+/** Exported for tests. */
+export declare function localHarnessSkills(dir: string): Array<{
+    name: string;
+    description: string;
+    content: string;
+}>;
+/**
+ * A built-in tool Claude Code wants to run that `permissionMode` does not
+ * auto-approve (anything that writes or shells out under `allow-reads`).
+ */
+export type LocalToolApproval = {
+    approvalId: string;
+    toolCallId: string;
+    toolName: string;
+    /** Compact one-line rendering of the tool input, for the prompt. */
+    summary: string;
+    input: unknown;
+};
+/** A tool starting or finishing, so the caller can show what is happening. */
+export type LocalToolActivity = {
+    kind: "start";
+    toolName: string;
+    summary: string;
+} | {
+    kind: "end";
+    toolName: string;
+    isError: boolean;
+};
+export type LocalStreamHandlers = {
+    onTextDelta?: (delta: string) => void;
+    /**
+     * Decide whether the tool may run. Omitted (`--print`, non-interactive)
+     * means deny — the turn continues and the model reports what it could not
+     * do rather than silently running commands on the user's machine.
+     */
+    onApproval?: (approval: LocalToolApproval) => Promise<boolean>;
+    onActivity?: (activity: LocalToolActivity) => void;
+    /** Path of a file the turn wrote or edited, as the tool named it. */
+    onFileTouched?: (path: string) => void;
+    /** Something worth saying that is not part of the reply. */
+    onNotice?: (message: string) => void;
+};
+export type LocalStreamOptions = LocalStreamHandlers & {
+    /** Aborts the turn; the harness interrupts Claude Code gracefully. */
+    abortSignal?: AbortSignal;
+};
+/**
+ * What one turn spent upstream, summed over the streams a suspended turn is
+ * made of. `costUsd` is Claude Code's own accounting; the API prices it into
+ * credits so the CLI never states a credit count itself.
+ */
+export type LocalTurnUsage = {
+    costUsd: number;
+    totalTokens: number;
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    reasoningTokens: number;
+};
+/**
+ * Text and usage of a turn in progress, owned by the caller rather than by
+ * `runPromptTurn`: a cancelled or failed turn still spent those tokens, and
+ * they have to reach the API anyway.
+ */
+export type LocalTurnAccumulator = {
+    chunks: string[];
+    usage: LocalTurnUsage;
+};
+/** Exported for tests. */
+export declare function createTurnAccumulator(): LocalTurnAccumulator;
+export type LocalHarnessHandle = {
+    streamPrompt: (question: string, options?: LocalStreamOptions) => Promise<string>;
+    /**
+     * When a turn last reached Anthropic, or undefined if none has. The proxy
+     * token re-arms on every call it makes, so this — not the mint time — is
+     * what its real expiry runs from.
+     */
+    proxyLastUsedAtMs: () => number | undefined;
+    /** Stops Claude Code and its bridge; the session is not resumable. */
+    close: () => Promise<void>;
+};
+/**
+ * The workspace half of local Ask: the hosted Cargo MCP server, reached
+ * through this CLI's own `mcp` bridge.
+ *
+ * Going through the bridge rather than configuring the HTTP endpoint directly
+ * is what keeps a long chat working — the bridge rebuilds the `Authorization`
+ * header per request from the same credentials every other command uses, so an
+ * OAuth session that expires mid-session renews instead of 401ing. `CARGO_BASE_URL`
+ * is pinned so the bridge cannot end up on a different API than this session.
+ *
+ * Everything the workspace can do arrives this way: actions, runs, models and
+ * SQL, the context, usage. That includes `execute_action`, which spends credits
+ * and writes to connected systems — see the approval note on
+ * `isAutoApproved`.
+ */
+/**
+ * What Claude Code mounts this server as, and so the `mcp__<server>__` prefix
+ * its tools carry. Read by `isAutoApproved`, which trusts this server and no
+ * other — see the note there.
+ *
+ * Exported for tests.
+ */
+export declare const CARGO_MCP_SERVER_NAME = "cargo";
+type WorkspaceLayout = {
+    sandboxCwd: string;
+    /** `undefined` leaves the harness its per-session default. */
+    workDir: string | undefined;
+};
+/**
+ * Where to root the sandbox, and which directory inside it the session works in.
+ *
+ * The harness gives every session a work directory under the sandbox root and
+ * starts Claude Code there — `cwd: workdir` in the bridge — and it refuses to
+ * use the root itself. Rooted at the project, that means the agent begins in an
+ * empty `claude-code-<sessionId>` directory one level below the working copy it
+ * was asked about. Rooting at the project's parent instead makes the session
+ * work directory *be* the project, so the agent starts where the user is, and
+ * the harness's own artifacts land beside the project rather than in it.
+ *
+ * Falls back to the project when the parent cannot serve — a project at a
+ * filesystem root has no usable name, and a parent we cannot write to would
+ * fail the session at startup. The per-session directory returns in that case,
+ * and `pruneHarnessArtifacts` sweeps it once it is cold.
+ */
+export declare function resolveWorkspaceLayout(dir: string): WorkspaceLayout;
+export declare function createLocalHarness(input: {
+    api: Api;
+    /**
+     * Cargo API origin (`config.baseUrl`). The Anthropic proxy is mounted on
+     * the API as `/sandbox/anthropic` — same host the backend uses via
+     * `config.app.url` (which is the API URL, not the web app).
+     */
+    apiBaseUrl: string;
+    dir: string;
+    chatUuid: string;
+    agentUuid?: string;
+    proxyToken: string;
+    /**
+     * Earlier turns of this chat, from `loadChatHistoryPreamble`. The session is
+     * always new, so this is the only thing that carries a `--continue` chat
+     * across CLI runs.
+     */
+    history?: string;
+    /**
+     * The id the caller claimed the chat with. Sent with the ingest so recording
+     * a turn releases this session's claim and not one taken after it.
+     */
+    turnOwnerId?: string;
+}): Promise<LocalHarnessHandle>;
+export type StreamLike = {
+    fullStream: AsyncIterable<unknown>;
+    text: PromiseLike<string>;
+};
+type ApprovalContinuation = {
+    approvalResponse: {
+        type: "tool-approval-response";
+        approvalId: string;
+        approved: boolean;
+        reason?: string;
+    };
+    toolCall: {
+        type: "tool-call";
+        toolCallId: string;
+        toolName: string;
+        input: unknown;
+    };
+};
+/** The two harness calls a turn needs. Split out so tests can fake them. */
+export type TurnDriver = {
+    start: () => Promise<StreamLike>;
+    continueWithApprovals: (continuations: readonly ApprovalContinuation[]) => Promise<StreamLike>;
+};
+/**
+ * Run one turn to completion, answering approval requests along the way.
+ *
+ * A turn suspends whenever Claude Code wants a tool `permissionMode` does not
+ * cover: the stream ends with the approvals still pending, and the turn only
+ * finishes once decisions are fed back in. Exported for tests.
+ */
+export declare function runPromptTurn(input: {
+    driver: TurnDriver;
+    handlers: LocalStreamHandlers | undefined;
+    accumulator?: LocalTurnAccumulator;
+    /**
+     * Filled with approvals the harness asked about and drained as each is
+     * answered, so a turn that ends mid-question leaves the unanswered ones
+     * behind for the caller to deny.
+     */
+    unanswered?: LocalToolApproval[];
+    /** Overridden by tests; `Infinity` waits forever. */
+    stallTimeoutMs?: number;
+}): Promise<string>;
+/**
+ * The previous turn could not be wound down, so this session cannot take
+ * another prompt. Raised rather than pressed on with: the harness would either
+ * refuse the prompt itself or run it alongside the turn we failed to finish.
+ *
+ * The caller's recovery is to replace the session — nothing about a wedged
+ * runtime gets better by asking it again.
+ */
+export declare class HarnessTurnStuck extends Error {
+    constructor();
+}
+/**
+ * Wait for `work`, but give up after `timeoutMs` rather than blocking a
+ * teardown forever. Resolves either way; the caller has already decided that
+ * an unfinished result is better than waiting.
+ *
+ * Exported for tests.
+ */
+export declare function settleWithin(work: Promise<unknown>, timeoutMs: number): Promise<void>;
+/** Exported for tests. */
+export declare function isAutoApproved(toolName: string): boolean;
+/** Exported for tests. */
+export declare function isAlwaysDenied(toolName: string): boolean;
+export {};
+//# sourceMappingURL=localHarness.d.ts.map

package/build/commands/ask/localHarness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localHarness.d.ts","sourceRoot":"","sources":["../../../src/commands/ask/localHarness.ts"],"names":[],"mappings":"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"}