cloving 1.2.0 → 1.4.0

package/dist/src/cli/arguments.d.ts

@@ -1,23 +1,34 @@
+import { type ConfigInvocation } from "./config-arguments.ts";
+import { type PhoneInvocation } from "./phone-arguments.ts";
 import { type RuntimeInvocation } from "./runtime-arguments.ts";
 export type Invocation = {
+    readonly repository?: string;
+} & (PhoneInvocation | ConfigInvocation | {
+    readonly kind: "config-help";
+} | {
     readonly kind: "help";
 } | {
     readonly kind: "version";
 } | {
-    readonly kind: "validate-help";
+    readonly kind: "mcp";
+} | {
+    readonly kind: "mcp-help";
+} | {
+    readonly kind: "init-prompt";
 } | {
-    readonly kind: "chats-redact-help";
+    readonly kind: "init";
+    readonly harness: string | undefined;
 } | {
-    readonly kind: "chats-redact";
-    readonly importId: string;
+    readonly kind: "init-prompt-help";
 } | {
-    readonly kind: "chats-import-help";
+    readonly kind: "init-help";
 } | {
-    readonly kind: "chats-import";
-    readonly paths: readonly string[];
-    readonly roots?: readonly string[];
-    readonly excludeProjects?: readonly string[];
-    readonly previousImportId?: string;
+    readonly kind: "doctor-help";
+} | {
+    readonly kind: "doctor";
+    readonly json: boolean;
+} | {
+    readonly kind: "validate-help";
 } | {
     readonly kind: "validate";
     readonly manifest: string;
@@ -27,5 +38,5 @@ export type Invocation = {
     readonly kind: "usage-error";
     readonly code: string;
     readonly json: boolean;
-};
+});
 export declare function parseInvocation(given: readonly string[]): Invocation;

package/dist/src/cli/arguments.js

@@ -1,4 +1,7 @@
 import { parseArgs } from "node:util";
+import { configInvocation } from "./config-arguments.js";
+import { repositoryArguments } from "./repository-arguments.js";
+import { phoneInvocation } from "./phone-arguments.js";
 import { isRuntimeCommand, runtimeInvocation, } from "./runtime-arguments.js";
 const errorCodes = {
     ERR_PARSE_ARGS_UNKNOWN_OPTION: "unknown-option",
@@ -21,6 +24,9 @@ const options = {
     limit: { type: "string" },
     after: { type: "string" },
     follow: { type: "boolean" },
+    since: { type: "string" },
+    repository: { type: "string" },
+    harness: { type: "string" },
 };
 const textOptions = ["--prompt", "--text"];
 function knownFlag(token) {
@@ -48,10 +54,27 @@ function textValues(argumentsList) {
     return option === undefined ? joined : [...joined, option];
 }
 export function parseInvocation(given) {
-    if (given[0] === "chats" && given[1] === "import")
-        return chatsImport(given.slice(2));
-    if (given[0] === "chats" && given[1] === "redact")
-        return chatsRedact(given.slice(2));
+    const selected = repositoryArguments(given, options);
+    if (typeof selected === "string")
+        return {
+            kind: "usage-error",
+            code: selected,
+            json: given.includes("--json"),
+        };
+    const invocation = selectedInvocation(selected.argumentsList);
+    return selected.repository === undefined
+        ? invocation
+        : { ...invocation, repository: selected.repository };
+}
+function selectedInvocation(given) {
+    if (given[0] === "config") {
+        const outcome = configInvocation(given.slice(1));
+        return typeof outcome === "string"
+            ? { kind: "usage-error", code: outcome, json: given.includes("--json") }
+            : outcome;
+    }
+    if (given[0] === "phone")
+        return phoneInvocation(given.slice(1));
     const argumentsList = textValues(given);
     const json = given.includes("--json");
     const parsed = parsedArguments(argumentsList);
@@ -61,6 +84,9 @@ export function parseInvocation(given) {
     const [command, ...remaining] = positionals;
     if (command === undefined)
         return topLevel(values);
+    const inspection = inspectionInvocation(command, { values, remaining });
+    if (inspection !== undefined)
+        return inspection;
     if (command === "workflows" && remaining[0] === "validate")
         return validation(values, remaining.slice(1));
     const outcome = runtimeInvocation({
@@ -72,109 +98,50 @@ export function parseInvocation(given) {
         return { kind: "usage-error", code: outcome, json };
     return outcome;
 }
-function chatsRedact(argumentsList) {
-    if (argumentsList.length === 1 &&
-        ["--help", "-h"].includes(String(argumentsList[0])))
-        return { kind: "chats-redact-help" };
-    const importId = argumentsList[0];
-    if (argumentsList.length !== 1 ||
-        importId === undefined ||
-        !/^[a-f\d]{8}-[a-f\d]{4}-4[a-f\d]{3}-[89ab][a-f\d]{3}-[a-f\d]{12}$/.test(importId))
-        return { kind: "usage-error", code: "invalid-import-id", json: false };
-    return { kind: "chats-redact", importId };
-}
-function chatsImport(argumentsList) {
-    const error = (code) => ({
-        kind: "usage-error",
-        code,
-        json: false,
-    });
-    if (argumentsList.length === 1 &&
-        ["--help", "-h"].includes(String(argumentsList[0])))
-        return { kind: "chats-import-help" };
-    const state = {
-        paths: [],
-        roots: [],
-        excludeProjects: [],
-        literal: false,
-        option: undefined,
-        previousImportId: undefined,
-    };
-    for (const argument of argumentsList) {
-        const failure = importArgument(state, argument);
-        if (failure !== undefined)
-            return error(failure);
+function inspectionInvocation(command, input) {
+    const { values, remaining } = input;
+    if (command === "init") {
+        if (unexpected(values, ["harness", "help"]))
+            return { kind: "usage-error", code: "unexpected-option", json: false };
+        if (remaining.length > 0)
+            return { kind: "usage-error", code: "unexpected-argument", json: false };
+        return values.help
+            ? { kind: "init-help" }
+            : { kind: "init", harness: values.harness };
     }
-    if (state.option !== undefined)
-        return error("missing-value");
-    if (state.excludeProjects.length > 0 && state.roots.length === 0)
-        return error("roots-required");
-    if (state.paths.length + state.roots.length === 0)
-        return error("missing-argument");
-    return importInvocation(state);
-}
-function importInvocation(state) {
-    const previous = state.previousImportId === undefined
-        ? {}
-        : { previousImportId: state.previousImportId };
-    return state.roots.length === 0
-        ? { kind: "chats-import", paths: state.paths, ...previous }
-        : {
-            kind: "chats-import",
-            paths: state.paths,
-            ...previous,
-            roots: state.roots,
-            excludeProjects: state.excludeProjects,
+    if (command === "doctor")
+        return doctorInvocation(values, remaining);
+    if (command === "mcp")
+        return mcpInvocation(values, remaining);
+    if (command === "init-prompt")
+        return promptInvocation(values, remaining);
+    return undefined;
+}
+function mcpInvocation(values, remaining) {
+    if (unexpected(values, ["help"]))
+        return { kind: "usage-error", code: "unexpected-option", json: false };
+    if (remaining.length > 0)
+        return { kind: "usage-error", code: "unexpected-argument", json: false };
+    return { kind: values.help ? "mcp-help" : "mcp" };
+}
+function promptInvocation(values, remaining) {
+    if (unexpected(values, ["help"]))
+        return {
+            kind: "usage-error",
+            code: "unexpected-option",
+            json: values.json === true,
         };
+    if (remaining.length > 0)
+        return { kind: "usage-error", code: "unexpected-argument", json: false };
+    return { kind: values.help ? "init-prompt-help" : "init-prompt" };
 }
-function importArgument(state, argument) {
-    if (state.option !== undefined)
-        return importValue(state, argument);
-    if (argument === "")
-        return "missing-argument";
-    if (state.literal) {
-        state.paths.push(argument);
-        return;
-    }
-    if (argument === "--previous-import" && state.previousImportId !== undefined)
-        return "repeated-previous-import";
-    if (["--root", "--exclude-project", "--previous-import"].includes(argument)) {
-        state.option = argument;
-        return;
-    }
-    if (argument === "--") {
-        state.literal = true;
-        return;
-    }
-    if (argument.startsWith("-"))
-        return "unexpected-option";
-    state.paths.push(argument);
-    return;
-}
-function importValue(state, argument) {
-    if (argument === "" || argument.startsWith("-"))
-        return "missing-value";
-    const option = state.option;
-    state.option = undefined;
-    if (option === "--root") {
-        state.roots.push(argument);
-        return;
-    }
-    if (option === "--exclude-project" && !validProjectName(argument))
-        return "invalid-exclusion";
-    if (option === "--exclude-project") {
-        state.excludeProjects.push(argument);
-        return;
-    }
-    if (!/^[a-f\d]{8}-[a-f\d]{4}-4[a-f\d]{3}-[89ab][a-f\d]{3}-[a-f\d]{12}$/.test(argument))
-        return "invalid-import-id";
-    state.previousImportId = argument;
-    return;
-}
-function validProjectName(name) {
-    return (name !== "." &&
-        name !== ".." &&
-        !["/", "\\", "\0", "*", "?", "[", "]"].some((character) => name.includes(character)));
+function doctorInvocation(values, remaining) {
+    const json = values.json === true;
+    if (unexpected(values, ["help", "json"]))
+        return { kind: "usage-error", code: "unexpected-option", json };
+    if (remaining.length > 0)
+        return { kind: "usage-error", code: "unexpected-argument", json };
+    return values.help ? { kind: "doctor-help" } : { kind: "doctor", json };
 }
 function parsedArguments(argumentsList) {
     try {
@@ -206,6 +173,8 @@ function knownCommand(positionals) {
         return true;
     if (command === "workflows")
         return subcommand === "validate";
+    if (["doctor", "init-prompt", "init", "mcp"].includes(command))
+        return true;
     return isRuntimeCommand(command);
 }
 function givenOptions(tokens) {

package/dist/src/cli/chat-stores.d.ts

@@ -0,0 +1,2 @@
+import type { ChatStore } from "./init-prompt.ts";
+export declare function chatStores(home: string | undefined): Promise<readonly ChatStore[]>;

package/dist/src/cli/chat-stores.js

@@ -0,0 +1,113 @@
+import { lstat, opendir } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+const knownStores = [
+    {
+        name: "Claude Code",
+        folder: ".claude/projects",
+        format: "JSONL",
+        documentation: "https://code.claude.com/docs/en/claude-directory",
+    },
+    {
+        name: "Codex",
+        folder: ".codex/sessions",
+        format: "JSONL, including zstd-compressed .jsonl.zst (read with zstd -dc)",
+        documentation: "https://learn.chatgpt.com/docs/security/sdk",
+    },
+    {
+        name: "Gemini CLI",
+        folder: ".gemini",
+        format: "JSON conversation history and checkpoints under tmp/<project>/",
+        documentation: "https://geminicli.com/docs/cli/checkpointing/",
+    },
+    {
+        name: "opencode",
+        folder: ".local/share/opencode",
+        format: "SQLite (opencode.db); older versions use JSON files under storage/",
+        documentation: "https://docs.opencode.ai/docs/troubleshooting/",
+    },
+    {
+        name: "grok",
+        folder: ".grok",
+        format: "JSONL ACP events in sessions/<encoded-cwd>/<session-id>/updates.jsonl; raw messages in chat_history.jsonl; JSON metadata",
+        documentation: "https://github.com/xai-org/grok-build/blob/main/crates/codegen/xai-grok-pager/docs/user-guide/17-sessions.md",
+    },
+    {
+        name: "Cursor Agent",
+        folder: ".cursor",
+        format: "JSONL under projects/<project>/agent-transcripts/ (older transcripts may be text)",
+        documentation: "https://forum.cursor.com/t/accessing-the-full-agent-transcript-in-cursor/157311/5",
+    },
+];
+async function metadata(path) {
+    return lstat(path).catch((error) => {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return null;
+        throw error;
+    });
+}
+async function* storeFiles(path) {
+    const pending = [path];
+    for (let folder = pending.pop(); folder !== undefined; folder = pending.pop()) {
+        const directory = await opendir(folder);
+        for await (const entry of directory) {
+            const file = join(folder, entry.name);
+            if (entry.isDirectory())
+                pending.push(file);
+            if (!entry.isFile())
+                continue;
+            const info = await metadata(file);
+            if (info?.isFile())
+                yield info;
+        }
+    }
+}
+async function measure(path) {
+    let fileCount = 0;
+    let totalBytes = 0;
+    let oldest = null;
+    let newest = null;
+    for await (const info of storeFiles(path)) {
+        fileCount += 1;
+        totalBytes += info.size;
+        oldest = Math.min(oldest ?? info.mtimeMs, info.mtimeMs);
+        newest = Math.max(newest ?? info.mtimeMs, info.mtimeMs);
+    }
+    return {
+        fileCount,
+        totalBytes,
+        oldestFileDate: oldest === null ? null : new Date(oldest).toISOString(),
+        newestFileDate: newest === null ? null : new Date(newest).toISOString(),
+    };
+}
+async function inspectStore(path) {
+    try {
+        if (!(await metadata(path))?.isDirectory())
+            return null;
+        return await measure(path);
+    }
+    catch (error) {
+        return {
+            unavailable: error instanceof Error &&
+                "code" in error &&
+                typeof error.code === "string"
+                ? error.code
+                : "scan-failed",
+            fileCount: null,
+            totalBytes: null,
+            oldestFileDate: null,
+            newestFileDate: null,
+        };
+    }
+}
+export async function chatStores(home) {
+    if (!home || !isAbsolute(home))
+        return [];
+    const stores = [];
+    for (const { folder, ...store } of knownStores) {
+        const path = join(home, folder);
+        const facts = await inspectStore(path);
+        if (facts)
+            stores.push({ ...store, path, ...facts });
+    }
+    return stores;
+}

package/dist/src/cli/client.d.ts

@@ -3,7 +3,10 @@ export interface Interruption {
     readonly signal: Promise<void>;
     readonly reply: Reply;
 }
-export declare function send(runtimeDirectory: string, request: ServiceRequest): Promise<Reply>;
+export interface ClientRequest extends ServiceRequest {
+    readonly signal?: AbortSignal;
+}
+export declare function send(runtimeDirectory: string, input: ClientRequest): Promise<Reply>;
 export declare function listRuns(runtimeDirectory: string): Promise<Reply>;
 export declare function mutate(runtimeDirectory: string, mutation: {
     readonly request: ServiceRequest;

package/dist/src/cli/client.js

@@ -41,7 +41,7 @@ function exchange(context) {
             error: { code: address.reason, detail: address.detail },
         });
     return new Promise((settle) => {
-        const socket = net.connect(address.path);
+        const socket = net.connect({ path: address.path, signal: context.signal });
         let buffered = "";
         let written = false;
         socket.setEncoding("utf8");
@@ -86,8 +86,14 @@ function exchange(context) {
     });
 }
 const unobserved = () => undefined;
-export function send(runtimeDirectory, request) {
-    return exchange({ runtimeDirectory, request, onEvent: unobserved });
+export function send(runtimeDirectory, input) {
+    const { signal, ...request } = input;
+    return exchange({
+        runtimeDirectory,
+        request,
+        onEvent: unobserved,
+        ...(signal === undefined ? {} : { signal }),
+    });
 }
 function listedRuns(result) {
     const runs = result["runs"];

package/dist/src/cli/command-effects.d.ts

@@ -0,0 +1,7 @@
+import type { CommandEffect } from "../command-settings.ts";
+import { type Shown } from "./watch-element.ts";
+export declare function shownCommands(value: unknown): readonly CommandEffect[];
+export declare function commandText(effect: CommandEffect): string;
+export declare function Commands(props: {
+    readonly effects: readonly CommandEffect[];
+}): Shown;

package/dist/src/cli/command-effects.js

@@ -0,0 +1,39 @@
+import { record } from "../protocol.js";
+import { element } from "./watch-element.js";
+export function shownCommands(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry) => {
+        const fields = record(entry);
+        if (typeof fields?.["operationId"] !== "string" ||
+            typeof fields["name"] !== "string" ||
+            typeof fields["state"] !== "string")
+            return [];
+        return [
+            {
+                operationId: fields["operationId"],
+                name: fields["name"],
+                state: fields["state"],
+                exitCode: typeof fields["exitCode"] === "number" ? fields["exitCode"] : null,
+                durationMilliseconds: typeof fields["durationMilliseconds"] === "number"
+                    ? fields["durationMilliseconds"]
+                    : null,
+            },
+        ];
+    });
+}
+export function commandText(effect) {
+    const duration = effect.durationMilliseconds === null
+        ? "duration unknown"
+        : `${String(effect.durationMilliseconds)} ms`;
+    return `Command ${effect.name} · ${effect.state} · exit ${effect.exitCode === null ? "unknown" : String(effect.exitCode)} · ${duration}`;
+}
+export function Commands(props) {
+    return props.effects.map((effect) => element("section", {
+        class: "command-effect code-window",
+        children: element("h3", {
+            class: "code-head",
+            children: commandText(effect),
+        }),
+    }));
+}

package/dist/src/cli/command-requests.d.ts

@@ -0,0 +1,17 @@
+import { type Fields, type Reply, type ServiceError, type ServiceRequest } from "../protocol.ts";
+import { type ClientRequest } from "./client.ts";
+export interface ReadCommand {
+    readonly kind: "status" | "questions" | "events";
+    readonly runId?: string | null;
+    readonly limit?: number | null;
+    readonly after?: string | number | null;
+    readonly follow?: boolean;
+}
+export declare function readCommandRequest(command: ReadCommand): ServiceRequest;
+export declare function readCommandReply(runtimeDirectory: string, request: ClientRequest): Promise<Reply>;
+export declare function errorObject(error: ServiceError, format?: {
+    readonly commandId?: string;
+}): Fields;
+export declare function commandJson(reply: Reply, format?: {
+    readonly commandId?: string;
+}): Fields;

package/dist/src/cli/command-requests.js

@@ -0,0 +1,43 @@
+import {} from "../protocol.js";
+import { send } from "./client.js";
+import { withCiReruns } from "./github-ci-progress.js";
+import { statusJson } from "./render.js";
+export function readCommandRequest(command) {
+    const { kind, runId, limit, after, follow } = command;
+    const parameters = kind === "questions"
+        ? { runId }
+        : { runId, limit, after, ...(follow === undefined ? {} : { follow }) };
+    return {
+        operation: kind,
+        parameters: Object.fromEntries(Object.entries(parameters).filter(([, value]) => value !== null && value !== undefined)),
+    };
+}
+export async function readCommandReply(runtimeDirectory, request) {
+    const reply = await send(runtimeDirectory, request);
+    return request.operation === "status"
+        ? await withCiReruns(runtimeDirectory, reply)
+        : reply;
+}
+export function errorObject(error, format = {}) {
+    if (error.code === "event-gap")
+        return {
+            schemaVersion: 1,
+            kind: "event-gap",
+            after: error["after"],
+            earliestAvailable: error["earliestAvailable"],
+            latestSequence: error["latestSequence"],
+        };
+    return {
+        schemaVersion: 1,
+        kind: "error",
+        ...error,
+        commandId: error["commandId"] ?? format.commandId ?? null,
+        runId: error["runId"] ?? null,
+        currentRevision: error["currentRevision"] ?? null,
+    };
+}
+export function commandJson(reply, format = {}) {
+    return reply.kind === "error"
+        ? errorObject(reply.error, format)
+        : statusJson(reply.result);
+}

package/dist/src/cli/command-waits.d.ts

@@ -0,0 +1,9 @@
+import { type Shown } from "./watch-element.ts";
+import type { CommandWaitView } from "../authority/command-wait-view.ts";
+export declare function shownCommandWaits(value: unknown): readonly CommandWaitView[];
+export declare function commandWaitText(wait: CommandWaitView): string;
+export declare function CommandWaits(props: {
+    readonly waits: readonly CommandWaitView[];
+}): Shown;
+export declare function effectBudgetText(spent: number | null | undefined, limit: number | null | undefined): string;
+export declare function activeCommandWait(waits: readonly CommandWaitView[]): boolean;

package/dist/src/cli/command-waits.js

@@ -0,0 +1,51 @@
+import { element } from "./watch-element.js";
+import { record } from "../protocol.js";
+function waitTime(value) {
+    return typeof value === "string" ? value : null;
+}
+export function shownCommandWaits(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry) => {
+        const fields = record(entry);
+        if (typeof fields?.["name"] !== "string" ||
+            typeof fields["command"] !== "string" ||
+            typeof fields["state"] !== "string" ||
+            typeof fields["maximumWaitSeconds"] !== "number" ||
+            typeof fields["remainingSeconds"] !== "number" ||
+            typeof fields["checkCount"] !== "number")
+            return [];
+        return [
+            {
+                name: fields["name"],
+                command: fields["command"],
+                state: fields["state"],
+                maximumWaitSeconds: fields["maximumWaitSeconds"],
+                remainingSeconds: fields["remainingSeconds"],
+                checkCount: fields["checkCount"],
+                startedAt: waitTime(fields["startedAt"]),
+                deadline: waitTime(fields["deadline"]),
+                nextCheckAt: waitTime(fields["nextCheckAt"]),
+                reason: waitTime(fields["reason"]),
+            },
+        ];
+    });
+}
+export function commandWaitText(wait) {
+    const reason = wait.reason === null ? "" : ` · ${wait.reason}`;
+    return `Command wait ${wait.name} · ${wait.command} · ${wait.state} · ${String(wait.remainingSeconds)} s left · deadline ${wait.deadline ?? "none"} · next check ${wait.nextCheckAt ?? "none"} · checks ${String(wait.checkCount)}${reason}`;
+}
+export function CommandWaits(props) {
+    return props.waits.map((wait) => element("p", {
+        class: "meta command-wait",
+        children: commandWaitText(wait),
+    }));
+}
+export function effectBudgetText(spent, limit) {
+    return spent == null || limit == null
+        ? ""
+        : `${String(spent)} of ${String(limit)} effect units`;
+}
+export function activeCommandWait(waits) {
+    return waits.some((wait) => wait.state === "waiting");
+}