@camerontaylor/paseo-cli 0.11.1-fork.1 → 0.11.2-fork.1

package/dist/commands/agent/artifacts-scan.d.ts

@@ -0,0 +1,21 @@
+import type { Command } from "commander";
+import type { CommandOptions, SingleResult } from "../../output/index.js";
+interface AgentArtifactsScanResult {
+    agentId: string;
+    addedOrUpdated: number;
+    total: number;
+}
+export interface ArtifactsScanOptions extends CommandOptions {
+    limit?: string;
+}
+export declare function addArtifactsScanOptions(command: Command): Command;
+/**
+ * Backfills an agent's artifact feed from files already on disk.
+ *
+ * Artifacts are normally collected per turn, so an agent that did its work
+ * before the feature existed shows an empty feed no matter how much it
+ * produced. This scans its working directory once and records what it finds.
+ */
+export declare function runArtifactsScanCommand(agentIdArg: string, options: ArtifactsScanOptions, _command: Command): Promise<SingleResult<AgentArtifactsScanResult>>;
+export {};
+//# sourceMappingURL=artifacts-scan.d.ts.map

package/dist/commands/agent/artifacts-scan.js

@@ -0,0 +1,66 @@
+import { connectToDaemon, getDaemonHost, resolveAgentId } from "../../utils/client.js";
+import { selectDaemonTarget } from "../../utils/daemon-target.js";
+const artifactsScanSchema = {
+    idField: "agentId",
+    columns: [
+        { header: "AGENT ID", field: "agentId" },
+        { header: "ADDED/UPDATED", field: "addedOrUpdated" },
+        { header: "TOTAL", field: "total" },
+    ],
+};
+export function addArtifactsScanOptions(command) {
+    return command.option("--limit <count>", "Maximum artifacts to retain, newest first (default: daemon default)");
+}
+/**
+ * Backfills an agent's artifact feed from files already on disk.
+ *
+ * Artifacts are normally collected per turn, so an agent that did its work
+ * before the feature existed shows an empty feed no matter how much it
+ * produced. This scans its working directory once and records what it finds.
+ */
+export async function runArtifactsScanCommand(agentIdArg, options, _command) {
+    let limit;
+    if (options.limit !== undefined) {
+        const parsed = Number.parseInt(options.limit, 10);
+        if (!Number.isFinite(parsed) || parsed <= 0) {
+            throw {
+                code: "INVALID_ARGUMENT",
+                message: `--limit must be a positive integer, got: ${options.limit}`,
+            };
+        }
+        limit = parsed;
+    }
+    const daemonTarget = selectDaemonTarget(options);
+    const host = getDaemonHost({ target: daemonTarget });
+    let client;
+    try {
+        client = await connectToDaemon({ target: daemonTarget });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+        };
+    }
+    try {
+        const payload = await client.fetchAgents({ filter: { includeArchived: true } });
+        const agentId = resolveAgentId(agentIdArg, payload.entries.map((entry) => entry.agent));
+        if (!agentId) {
+            throw {
+                code: "AGENT_NOT_FOUND",
+                message: `Agent not found: ${agentIdArg}`,
+            };
+        }
+        const result = await client.scanAgentArtifacts(agentId, limit !== undefined ? { limit } : {});
+        return {
+            type: "single",
+            data: { agentId, addedOrUpdated: result.addedOrUpdated, total: result.total },
+            schema: artifactsScanSchema,
+        };
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+//# sourceMappingURL=artifacts-scan.js.map

package/dist/commands/agent/index.js

@@ -11,6 +11,7 @@ import { addInspectOptions, runInspectCommand } from "./inspect.js";
 import { addWaitOptions, runWaitCommand } from "./wait.js";
 import { addAttachOptions, runAttachCommand } from "./attach.js";
 import { addReloadOptions, runReloadCommand } from "./reload.js";
+import { addArtifactsScanOptions, runArtifactsScanCommand } from "./artifacts-scan.js";
 import { addImportOptions, runImportCommand } from "./import.js";
 import { runUpdateCommand } from "./update.js";
 import { runDetachCommand } from "./detach.js";
@@ -40,6 +41,10 @@ export function createAgentCommand() {
         .option("--list", "List available modes for this agent")).action(withOutput(runModeCommand));
     addJsonAndDaemonHostOptions(addArchiveOptions(agent.command("archive"))).action(withOutput(runArchiveCommand));
     addJsonAndDaemonHostOptions(addReloadOptions(agent.command("reload"))).action(withOutput(runReloadCommand));
+    addJsonAndDaemonHostOptions(addArtifactsScanOptions(agent
+        .command("artifacts-scan")
+        .description("Backfill an agent's artifact feed from files already on disk")
+        .argument("<id>", "Agent ID, prefix, or name"))).action(withOutput(runArtifactsScanCommand));
     addJsonAndDaemonHostOptions(agent
         .command("detach")
         .description("Make a subagent independent without stopping or moving it")

package/dist/commands/agent/run.d.ts

@@ -1,6 +1,8 @@
 import { Command } from "commander";
+import { type DaemonClient } from "@camerontaylor/paseo-client/internal/daemon-client";
 import { connectToDaemon } from "../../utils/client.js";
 import type { CommandOptions, SingleResult, OutputSchema } from "../../output/index.js";
+import { type ResolvedProviderModel } from "../../utils/provider-model.js";
 export { resolveProviderAndModel } from "../../utils/provider-model.js";
 export declare function addRunOptions(cmd: Command): Command;
 /** Result type for agent run command */
@@ -71,6 +73,11 @@ export interface RunWorkspaceLookupClient {
     }>;
 }
 export declare function resolveExistingRunWorkspace(client: RunWorkspaceLookupClient, workspaceId: string): Promise<RunWorkspace>;
+interface ResolveRunThinkingOptionInput extends ResolvedProviderModel {
+    cwd: string;
+    thinking: string | undefined;
+}
+export declare function resolveRunThinkingOption(client: Pick<DaemonClient, "listProviderModels">, input: ResolveRunThinkingOptionInput): Promise<string | undefined>;
 export declare function runRunCommand(prompt: string, options: AgentRunOptions, _command: Command): Promise<SingleResult<AgentRunResult>>;
 export interface RunCallerLookupClient {
     fetchAgent(options: {

package/dist/commands/agent/run.js

@@ -412,6 +412,19 @@ async function resolveRunWorkspace(client, options, cwd, callerAgentId) {
     console.error("Tip: pass --workspace <id> (or set PASEO_WORKSPACE_ID) to run in an existing workspace.");
     return { id: result.workspace.id, cwd: result.workspace.workspaceDirectory ?? cwd };
 }
+export async function resolveRunThinkingOption(client, input) {
+    if (input.thinking !== undefined)
+        return input.thinking;
+    const result = await client.listProviderModels(input.provider, { cwd: input.cwd });
+    if (result.error) {
+        throw { code: "PROVIDER_ERROR", message: result.error };
+    }
+    const models = result.models ?? [];
+    const model = input.model
+        ? models.find((candidate) => candidate.id === input.model)
+        : (models.find((candidate) => candidate.isDefault) ?? models[0]);
+    return (model?.defaultThinkingOptionId ?? model?.thinkingOptions?.find((option) => option.isDefault)?.id);
+}
 export async function runRunCommand(prompt, options, _command) {
     const outputSchema = options.outputSchema ? loadOutputSchema(options.outputSchema) : undefined;
     validateRunOptions(prompt, options, outputSchema);
@@ -422,8 +435,8 @@ export async function runRunCommand(prompt, options, _command) {
     try {
         // Resolve working directory
         const cwd = options.cwd ?? process.cwd();
-        const thinkingOptionId = options.thinking?.trim();
-        if (options.thinking !== undefined && !thinkingOptionId) {
+        const requestedThinkingOptionId = options.thinking?.trim();
+        if (options.thinking !== undefined && !requestedThinkingOptionId) {
             const error = {
                 code: "INVALID_THINKING_OPTION",
                 message: "--thinking cannot be empty",
@@ -439,6 +452,11 @@ export async function runRunCommand(prompt, options, _command) {
         const workspace = await resolveRunWorkspace(client, options, cwd, callerAgentId);
         const workspaceId = workspace.id;
         const runCwd = workspace.cwd;
+        const thinkingOptionId = await resolveRunThinkingOption(client, {
+            ...resolvedProviderModel,
+            cwd: runCwd,
+            thinking: requestedThinkingOptionId,
+        });
         if (outputSchema) {
             let structuredAgent = null;
             const callStructuredTurn = async (structuredPrompt) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camerontaylor/paseo-cli",
-  "version": "0.11.1-fork.1",
+  "version": "0.11.2-fork.1",
   "description": "Paseo CLI - control your AI coding agents from the command line",
   "bin": {
     "paseo": "bin/paseo"
@@ -28,9 +28,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.0.0",
-    "@camerontaylor/paseo-client": "0.11.1-fork.1",
-    "@camerontaylor/paseo-protocol": "0.11.1-fork.1",
-    "@camerontaylor/paseo-server": "0.11.1-fork.1",
+    "@camerontaylor/paseo-client": "0.11.2-fork.1",
+    "@camerontaylor/paseo-protocol": "0.11.2-fork.1",
+    "@camerontaylor/paseo-server": "0.11.2-fork.1",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "mime-types": "^2.1.35",