@cargo-ai/cli 1.0.77 → 1.0.80

package/build/commands/ask/completer.js

@@ -0,0 +1,217 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep, } from "node:path";
+/** Chat slash commands offered on Tab when the line is `/…`. */
+export const ASK_SLASH_COMMANDS = [
+    "/help",
+    "/clear",
+    "/new",
+    "/agent",
+    "/cancel",
+    "/exit",
+];
+/**
+ * Decide whether a `/…` token is a chat command, a filesystem path, or
+ * neither.
+ *
+ * The completer and the slash parser both need this answer, and they must
+ * agree: anything the completer offers has to be accepted when the user
+ * presses Enter on it. Written twice, the two drifted — `/tmp` completed as a
+ * path and was then answered with "is not a chat command".
+ *
+ * Shape settles most tokens, but a bare `/word` is ambiguous: `/tmp` and
+ * `/orchestration` are spelled the same. Only the filesystem separates them,
+ * so an unknown word is looked up — cheap, and reached only for a single
+ * bare word that no command matches.
+ */
+export function classifySlashToken(token) {
+    // A separator beyond the leading one is unambiguously a path.
+    if (token.slice(1).includes("/") === true) {
+        return "path";
+    }
+    // Still a command while it prefixes one (`/he` → `/help`).
+    if (ASK_SLASH_COMMANDS.some((command) => command.startsWith(token)) === true) {
+        return "command";
+    }
+    // A bare word is only a path if one exists — `/deploy-prod` is a typo worth
+    // a card, not prose to spend a turn on.
+    return existsSync(token) === true ? "path" : "unknown";
+}
+/** Max rows shown in the live Ask suggestion menu. */
+export const ASK_COMPLETION_MENU_LIMIT = 8;
+/**
+ * Tab completer for the Ask prompt: slash commands when the line is `/…`,
+ * otherwise local path completion for a path-like last token.
+ */
+export function createAskCompleter(cwd) {
+    return (line) => {
+        const slash = completeSlash(line);
+        if (slash !== undefined) {
+            return slash;
+        }
+        return completePath(line, cwd);
+    };
+}
+/**
+ * Matches for the live suggestion menu (slash commands, else path hits).
+ * Empty when the line is plain prose.
+ */
+export function listCompletions(line, cwd) {
+    const slash = completeSlash(line);
+    if (slash !== undefined) {
+        return slash[0];
+    }
+    const [hits] = completePath(line, cwd);
+    return hits;
+}
+/**
+ * Replace the completed span with `completion`: whole line for slash
+ * commands, last token for paths.
+ */
+export function applyCompletion(line, completion) {
+    if (completeSlash(line) !== undefined) {
+        return completion;
+    }
+    const token = lastToken(line);
+    if (token === undefined) {
+        return completion;
+    }
+    return `${line.slice(0, line.length - token.length)}${completion}`;
+}
+/**
+ * `/hel` → `/help`. Only when the whole line is a single `/token` (no spaces)
+ * and it matches a chat command prefix. `/tmp` falls through to path completion.
+ */
+export function completeSlash(line) {
+    if (/^\/[A-Za-z]*$/.test(line) === false) {
+        return undefined;
+    }
+    const hits = ASK_SLASH_COMMANDS.filter((command) => command.startsWith(line));
+    if (hits.length === 0) {
+        return undefined;
+    }
+    return [[...hits], line];
+}
+/**
+ * Complete the last whitespace-separated token when it looks like a path.
+ * Exported for tests.
+ */
+export function completePath(line, cwd) {
+    const token = lastToken(line);
+    if (token === undefined || isPathLike(token) === false) {
+        return [[], line];
+    }
+    const expanded = expandHome(token);
+    const absoluteBase = isAbsolute(expanded) ? expanded : resolve(cwd, expanded);
+    let dir;
+    let namePrefix;
+    // `.`, `..` and `~` name a directory to look inside, the same as a trailing
+    // separator. Splitting them with dirname/basename instead would complete
+    // siblings of the current, parent or home directory.
+    if (token.endsWith("/") ||
+        token.endsWith(sep) ||
+        token === "." ||
+        token === ".." ||
+        token === "~") {
+        dir = absoluteBase;
+        namePrefix = "";
+    }
+    else {
+        dir = dirname(absoluteBase);
+        namePrefix = basename(absoluteBase);
+    }
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return [[], token];
+    }
+    const hits = [];
+    for (const entry of entries) {
+        if (entry.startsWith(namePrefix) === false) {
+            continue;
+        }
+        // Hide dotfiles until the name being typed starts with a dot. Listing a
+        // directory (`.`, `~`, a trailing slash) has an empty prefix, so those
+        // stay hidden there too.
+        if (entry.startsWith(".") === true &&
+            namePrefix.startsWith(".") === false) {
+            continue;
+        }
+        const absoluteHit = join(dir, entry);
+        let display = collapseHome(toDisplayPath(absoluteHit, cwd, token));
+        try {
+            if (statSync(absoluteHit).isDirectory() === true) {
+                display = display.endsWith("/") ? display : `${display}/`;
+            }
+        }
+        catch {
+            // Skip unreadable entries.
+            continue;
+        }
+        hits.push(display);
+    }
+    hits.sort((a, b) => a.localeCompare(b));
+    return [hits, token];
+}
+function lastToken(line) {
+    const match = /(?:^|\s)(\S+)$/.exec(line);
+    if (match === null) {
+        return undefined;
+    }
+    return match[1];
+}
+function isPathLike(token) {
+    if (token.startsWith("./") === true ||
+        token.startsWith("../") === true ||
+        token.startsWith("~/") === true ||
+        token === "~" ||
+        token === "." ||
+        token === "..") {
+        return true;
+    }
+    if (token.startsWith("/") === true) {
+        return classifySlashToken(token) !== "command";
+    }
+    return token.includes("/");
+}
+function expandHome(token) {
+    if (token === "~") {
+        return homedir();
+    }
+    if (token.startsWith("~/") === true) {
+        return join(homedir(), token.slice(2));
+    }
+    return token;
+}
+function collapseHome(path) {
+    const home = homedir();
+    if (path === home) {
+        return "~";
+    }
+    if (path.startsWith(`${home}/`) === true) {
+        return `~/${path.slice(home.length + 1)}`;
+    }
+    return path;
+}
+/**
+ * Prefer a relative form when the typed token was relative; keep absolute /
+ * home forms when the user started that way.
+ */
+function toDisplayPath(absolute, cwd, typedToken) {
+    if (typedToken.startsWith("~/") === true || typedToken === "~") {
+        return absolute;
+    }
+    if (isAbsolute(typedToken) === true) {
+        return absolute;
+    }
+    const rel = relative(cwd, absolute);
+    const display = rel === "" ? "." : rel;
+    if (typedToken.startsWith("./") === true &&
+        display.startsWith(".") === false &&
+        isAbsolute(display) === false) {
+        return `./${display}`;
+    }
+    return display;
+}

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

@@ -0,0 +1,32 @@
+import type { Api } from "../../api.js";
+/**
+ * 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 declare function loadChatHistoryPreamble(input: {
+    api: Api;
+    chatUuid: string;
+}): Promise<string | undefined>;
+type HistoryMessage = {
+    type: string;
+    status?: string;
+    parts: Array<{
+        type: string;
+    }>;
+};
+/**
+ * Exported for tests. Takes the API's messages oldest-first and returns the
+ * preamble, or `undefined` when there is nothing worth replaying.
+ */
+export declare function renderHistoryPreamble(messages: readonly HistoryMessage[]): string | undefined;
+export {};
+//# sourceMappingURL=history.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../../src/commands/ask/history.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AA0BxC;;;;;;;;;;;;GAYG;AACH,wBAAsB,uBAAuB,CAAC,KAAK,EAAE;IACnD,GAAG,EAAE,GAAG,CAAC;IACT,QAAQ,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAU9B;AAED,KAAK,cAAc,GAAG;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAChC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,SAAS,cAAc,EAAE,GAClC,MAAM,GAAG,SAAS,CA6CpB"}

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();
+        }
+    });
+}