@skrr-ai/cli 0.1.92 → 0.1.94

package/dist/commands/tasks/bulk-update.js

@@ -5,12 +5,15 @@ const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const web_url_1 = require("../../lib/web-url");
 const prompt_1 = require("../../lib/prompt");
+const dry_run_plans_1 = require("../../lib/dry-run-plans");
+const task_batch_1 = require("../../lib/task-batch");
 const tasks_1 = require("../../lib/tasks");
 class TasksBulkUpdate extends base_command_1.BaseCommand {
     static description = 'Apply partial updates to many tasks from JSON';
     static examples = [
         '<%= config.bin %> tasks bulk-update --from-json updates.json --json',
         '<%= config.bin %> tasks bulk-update --from-json updates.json --continue-on-error',
+        '<%= config.bin %> tasks bulk-update --from-json updates.json --dry-run --json',
     ];
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output bulk result as JSON' }),
@@ -18,6 +21,9 @@ class TasksBulkUpdate extends base_command_1.BaseCommand {
             description: 'Path to a JSON file (or "-" for stdin) containing updates',
             required: true,
         }),
+        'dry-run': core_1.Flags.boolean({
+            description: 'Read each task, validate every patch client-side and print the field-by-field diff without writing anything',
+        }),
         'continue-on-error': core_1.Flags.boolean({
             description: 'Continue applying later updates after one task fails',
         }),
@@ -39,42 +45,127 @@ class TasksBulkUpdate extends base_command_1.BaseCommand {
         catch (err) {
             this.error(err.message, { exit: 1 });
         }
+        if (flags['dry-run']) {
+            const currentById = {};
+            const failedReads = {};
+            for (const update of updates) {
+                try {
+                    currentById[update.id] = (await data_provider_1.dataService.getTask(update.id, {
+                        enrich: false,
+                    }));
+                }
+                catch (err) {
+                    const status = err.status;
+                    if (status === 404)
+                        currentById[update.id] = null;
+                    else
+                        failedReads[update.id] = err instanceof Error ? err.message : String(err);
+                }
+            }
+            const preview = (0, dry_run_plans_1.planBulkUpdate)(updates, currentById, failedReads);
+            if (flags.json)
+                this.log(JSON.stringify(preview, null, 2));
+            else {
+                this.log(`Dry run: ${preview.wouldChange} of ${preview.requested} task(s) would change, ${preview.invalid} invalid. Nothing was written.`);
+                for (const row of preview.results) {
+                    if (!row.ok)
+                        this.log(`- ${row.id}: ${row.errors.join('; ')}`);
+                    else if (row.noop)
+                        this.log(`- ${row.id}: no change`);
+                    else
+                        this.log(`- ${row.id}: ${Object.keys(row.changes).join(', ')}`);
+                }
+            }
+            if (!preview.ok)
+                this.exit(1);
+            return;
+        }
         const results = [];
         const errors = [];
-        for (const update of updates) {
+        const rows = updates.map((update) => {
+            const { status, ...restPatch } = update.patch;
+            return { id: update.id, status, patch: (0, tasks_1.removeUndefinedFields)(restPatch) };
+        });
+        // The field patches go to PATCH /api/tasks/batch in chunks; `status` is a
+        // workflow move with its own route and stays one call per row. A server
+        // without the batch route (404/405) gets the serial path below.
+        const patchable = rows
+            .map((row, index) => ({ row, index }))
+            .filter(({ row }) => Object.keys(row.patch).length > 0);
+        const batchByRow = new Map();
+        if (patchable.length > 0) {
+            const outcome = await (0, task_batch_1.patchTasksViaBatch)(patchable.map(({ row }) => ({
+                id: row.id,
+                patch: row.patch,
+            })));
+            if (outcome.supported) {
+                for (const [i, result] of outcome.results.entries()) {
+                    batchByRow.set(patchable[i].index, result);
+                }
+            }
+        }
+        const usedBatch = batchByRow.size > 0;
+        let stopped = false;
+        for (const [index, row] of rows.entries()) {
             try {
-                const { status, ...restPatch } = update.patch;
-                const patch = (0, tasks_1.removeUndefinedFields)(restPatch);
                 let task = null;
-                if (Object.keys(patch).length > 0) {
-                    task = await data_provider_1.dataService.updateTask({
-                        taskId: update.id,
-                        data: patch,
-                    });
+                if (Object.keys(row.patch).length > 0) {
+                    const batched = batchByRow.get(index);
+                    if (usedBatch && batched) {
+                        if (!batched.ok) {
+                            throw Object.assign(new Error(batched.error?.message ?? 'Update failed'), {
+                                code: batched.error?.code,
+                                status: batched.error?.status,
+                            });
+                        }
+                        // The batch route reports id/identifier/version, not the document:
+                        // the fields this row set are echoed so the row is self-describing.
+                        task = {
+                            ...row.patch,
+                            id: batched.id ?? row.id,
+                            ...(batched.identifier ? { identifier: batched.identifier } : {}),
+                            ...(batched.version !== undefined ? { version: batched.version } : {}),
+                        };
+                    }
+                    else {
+                        task = await data_provider_1.dataService.updateTask({
+                            taskId: row.id,
+                            data: row.patch,
+                        });
+                    }
                 }
-                if (status !== undefined) {
-                    if (!data_provider_1.TASK_STATUSES.includes(status)) {
+                if (row.status !== undefined) {
+                    if (stopped) {
+                        throw new Error('status move not applied: stopped after an earlier failure');
+                    }
+                    if (!data_provider_1.TASK_STATUSES.includes(row.status)) {
                         throw new Error(`status must be one of: ${data_provider_1.TASK_STATUSES.join(', ')}`);
                     }
                     task = await data_provider_1.dataService.moveTask({
-                        taskId: update.id,
-                        status: status,
+                        taskId: row.id,
+                        status: row.status,
                     });
                 }
                 if (!task) {
-                    task = await data_provider_1.dataService.getTask(update.id, { enrich: false });
+                    task = await data_provider_1.dataService.getTask(row.id, { enrich: false });
                 }
-                results.push({ id: update.id, ok: true, task });
+                results.push({ id: row.id, ok: true, task });
             }
             catch (err) {
+                const code = err.code;
                 const error = {
-                    id: update.id,
+                    id: row.id,
                     ok: false,
                     error: err instanceof Error ? err.message : String(err),
+                    ...(code ? { code } : {}),
                 };
                 errors.push(error);
                 results.push(error);
                 if (!flags['continue-on-error'])
+                    stopped = true;
+                // Serial path: later rows are never touched. Batch path: they were
+                // already applied by the chunk, so they are reported rather than dropped.
+                if (!flags['continue-on-error'] && !usedBatch)
                     break;
             }
         }

package/dist/commands/tasks/cancel-cascade.d.ts

@@ -7,6 +7,7 @@ export default class TasksCancelCascade extends BaseCommand {
     };
     static flags: {
         yes: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/commands/tasks/cancel-cascade.js

@@ -15,29 +15,39 @@ class TasksCancelCascade extends base_command_1.BaseCommand {
     };
     static flags = {
         yes: core_1.Flags.boolean({ char: 'y', description: 'Skip confirmation prompt' }),
+        json: core_1.Flags.boolean({ description: 'Output the result as JSON' }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksCancelCascade);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         let confirmed;
         try {
-            confirmed = await (0, prompt_1.confirmDestructive)(`Cancel cascade for task ${args.id}? This cannot be undone.`, flags.yes);
+            confirmed = await (0, prompt_1.confirmDestructive)(`Cancel cascade for task ${taskRef}? This cannot be undone.`, flags.yes);
         }
         catch (err) {
             const e = err;
             this.error(e.message, { exit: e.exit ?? 1 });
         }
         if (!confirmed) {
+            if (flags.json) {
+                this.log(JSON.stringify({ object: 'task_cascade_cancel', cancelled: false, id: taskRef }));
+                return;
+            }
             this.log('Cancelled.');
             return;
         }
         try {
-            await data_provider_1.dataService.cancelCascade(args.id);
+            await data_provider_1.dataService.cancelCascade(taskRef);
         }
         catch (err) {
             this.handleApiError(err);
         }
-        this.log(`Cancelled cascade for task ${args.id}`);
+        if (flags.json) {
+            this.log(JSON.stringify({ object: 'task_cascade_cancel', cancelled: true, id: taskRef }));
+            return;
+        }
+        this.log(`Cancelled cascade for task ${taskRef}`);
     }
 }
 exports.default = TasksCancelCascade;

package/dist/commands/tasks/cascade-status.js

@@ -18,9 +18,10 @@ class TasksCascadeStatus extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksCascadeStatus);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         let result;
         try {
-            result = await data_provider_1.dataService.getCascadeStatus(args.id);
+            result = await data_provider_1.dataService.getCascadeStatus(taskRef);
         }
         catch (err) {
             this.handleApiError(err);

package/dist/commands/tasks/checkout.js

@@ -54,10 +54,11 @@ class TasksCheckout extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksCheckout);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         const runId = flags.run ?? crypto.randomUUID();
         let result;
         try {
-            result = await data_provider_1.dataService.checkoutTask({ taskId: args.id, runId });
+            result = await data_provider_1.dataService.checkoutTask({ taskId: taskRef, runId });
         }
         catch (err) {
             const e = err;
@@ -73,7 +74,7 @@ class TasksCheckout extends base_command_1.BaseCommand {
             this.log(JSON.stringify(result, null, 2));
             return;
         }
-        this.log(`Checked out task ${args.id} with run ${runId}`);
+        this.log(`Checked out task ${taskRef} with run ${runId}`);
     }
 }
 exports.default = TasksCheckout;

package/dist/commands/tasks/children.js

@@ -20,9 +20,10 @@ class TasksChildren extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksChildren);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         let response;
         try {
-            response = await data_provider_1.dataService.listTaskChildren(args.id);
+            response = await data_provider_1.dataService.listTaskChildren(taskRef);
         }
         catch (err) {
             this.handleApiError(err);

package/dist/commands/tasks/comments/add.js

@@ -128,6 +128,7 @@ class TasksCommentsAdd extends base_command_1.BaseCommand {
                 details: { suggestion: failure.suggestion, context: failure.details },
             });
         }
+        const taskRef = await this.resolveEntityRef('task', task.id);
         const commentBody = (0, task_resolver_1.stripTaskIdentityFields)(jsonBody);
         if ('authorAgentId' in commentBody || 'author-agent' in commentBody) {
             this.failWithCliError({
@@ -154,7 +155,7 @@ class TasksCommentsAdd extends base_command_1.BaseCommand {
             for (const filePath of flags.attach) {
                 try {
                     const asset = await uploadTaskAssetFile({
-                        taskId: task.id,
+                        taskId: taskRef,
                         filePath,
                         role: 'evidence',
                     });
@@ -200,7 +201,7 @@ class TasksCommentsAdd extends base_command_1.BaseCommand {
         // ONE key for the original attempt and any later replay — see the comment
         // in `spaces create`. A key sent only on the replay would post a second
         // comment whenever the original landed and its response was lost.
-        const idempotencyKey = (0, outbox_1.idempotencyKeyFor)('task-comment', task.id, JSON.stringify(data));
+        const idempotencyKey = (0, outbox_1.idempotencyKeyFor)('task-comment', taskRef, JSON.stringify(data));
         let result;
         try {
             // apiFetch rather than `dataService.addTaskComment`: the shared transport
@@ -233,7 +234,7 @@ class TasksCommentsAdd extends base_command_1.BaseCommand {
                     },
                     headers: { 'X-Idempotency-Key': idempotencyKey },
                 })
-                : await (0, api_fetch_1.apiFetch)(`/api/tasks/${encodeURIComponent(task.id)}/comments`, {
+                : await (0, api_fetch_1.apiFetch)(`/api/tasks/${encodeURIComponent(taskRef)}/comments`, {
                     method: 'POST',
                     body: data,
                     headers: { 'X-Idempotency-Key': idempotencyKey },
@@ -247,9 +248,9 @@ class TasksCommentsAdd extends base_command_1.BaseCommand {
             // different comment on the same task hashes differently and still posts.
             this.queueWriteOrFail(err, {
                 command: 'tasks comments add',
-                summary: `comment on task ${task.id}`,
+                summary: `comment on task ${taskRef}`,
                 method: 'post',
-                url: `/api/tasks/${encodeURIComponent(task.id)}/comments`,
+                url: `/api/tasks/${encodeURIComponent(taskRef)}/comments`,
                 body: data,
                 idempotencyKey,
             });
@@ -264,7 +265,7 @@ class TasksCommentsAdd extends base_command_1.BaseCommand {
             : c.anchor?.commentMarkId
                 ? 'inline comment'
                 : 'comment';
-        this.log(`Added ${kind} ${c.id ?? c._id ?? '?'} on task ${task.id}`);
+        this.log(`Added ${kind} ${c.id ?? c._id ?? '?'} on task ${taskRef}`);
         if (c.anchor?.commentMarkId) {
             this.log(`  anchor markId: ${c.anchor.commentMarkId}`);
             if (c.anchor.quote) {

package/dist/commands/tasks/comments/anchor.js

@@ -228,6 +228,7 @@ class TasksCommentsAnchor extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksCommentsAnchor);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         if (flags.occurrence < 1) {
             this.error('--occurrence must be ≥ 1', { exit: 1 });
         }
@@ -244,7 +245,7 @@ class TasksCommentsAnchor extends base_command_1.BaseCommand {
         // 1. Fetch current task.
         let task;
         try {
-            task = await data_provider_1.dataService.getTask(args.id, { enrich: false });
+            task = await data_provider_1.dataService.getTask(taskRef, { enrich: false });
         }
         catch (err) {
             this.handleApiError(err);
@@ -275,9 +276,9 @@ class TasksCommentsAnchor extends base_command_1.BaseCommand {
                 '',
                 'Workarounds:',
                 `  • Edit the description first so the target text lives in one span:`,
-                `      skrr tasks update ${args.id} --description "…"`,
+                `      skrr tasks update ${taskRef} --description "…"`,
                 `  • Or post the anchor without modifying the description:`,
-                `      skrr tasks comments add ${args.id} --body "…" --anchor-quote "…"`,
+                `      skrr tasks comments add ${taskRef} --body "…" --anchor-quote "…"`,
                 '    (the editor will treat the comment as a sticky thread even without',
                 '    a visible span.)',
             ].join('\n'), { exit: 1 });
@@ -304,7 +305,7 @@ class TasksCommentsAnchor extends base_command_1.BaseCommand {
             : { description: wrap.html };
         let patched;
         try {
-            patched = await data_provider_1.dataService.updateTask({ taskId: args.id, data: patchData });
+            patched = await data_provider_1.dataService.updateTask({ taskId: taskRef, data: patchData });
         }
         catch (err) {
             const e = err;
@@ -331,7 +332,7 @@ class TasksCommentsAnchor extends base_command_1.BaseCommand {
         let comment;
         try {
             comment = await data_provider_1.dataService.addTaskComment({
-                taskId: args.id,
+                taskId: taskRef,
                 data: commentData,
             });
         }
@@ -343,7 +344,7 @@ class TasksCommentsAnchor extends base_command_1.BaseCommand {
             // our PATCH and rollback, we accept that they win and warn the user.
             try {
                 await data_provider_1.dataService.updateTask({
-                    taskId: args.id,
+                    taskId: taskRef,
                     data: { description: originalDescription },
                 });
                 this.warn('Comment POST failed — rolled back description to its pre-anchor state.');
@@ -361,7 +362,7 @@ class TasksCommentsAnchor extends base_command_1.BaseCommand {
             return;
         }
         const c = comment;
-        this.log(`Anchored comment ${c.id ?? c._id ?? '?'} on task ${args.id}`);
+        this.log(`Anchored comment ${c.id ?? c._id ?? '?'} on task ${taskRef}`);
         this.log(`  mark id: ${markId}`);
         this.log(`  match:   occurrence ${wrap.occurrence} of ${wrap.totalMatches}`);
         this.log(`  quote:   "${quote.length > 80 ? quote.slice(0, 77) + '…' : quote}"`);

package/dist/commands/tasks/comments/delete.js

@@ -20,9 +20,10 @@ class TasksCommentsDelete extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksCommentsDelete);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         let confirmed;
         try {
-            confirmed = await (0, prompt_1.confirmDestructive)(`Delete comment ${args.commentId} from task ${args.id}? This cannot be undone.`, flags.yes);
+            confirmed = await (0, prompt_1.confirmDestructive)(`Delete comment ${args.commentId} from task ${taskRef}? This cannot be undone.`, flags.yes);
         }
         catch (err) {
             const e = err;
@@ -33,7 +34,7 @@ class TasksCommentsDelete extends base_command_1.BaseCommand {
             return;
         }
         try {
-            await data_provider_1.dataService.deleteTaskComment({ taskId: args.id, commentId: args.commentId });
+            await data_provider_1.dataService.deleteTaskComment({ taskId: taskRef, commentId: args.commentId });
         }
         catch (err) {
             this.handleApiError(err);

package/dist/commands/tasks/comments/list.js

@@ -83,9 +83,10 @@ class TasksCommentsList extends base_command_1.BaseCommand {
                 details: { suggestion: failure.suggestion, context: failure.details },
             });
         }
+        const taskRef = await this.resolveEntityRef('task', task.id);
         let response;
         try {
-            response = await data_provider_1.dataService.listTaskComments(task.id, {
+            response = await data_provider_1.dataService.listTaskComments(taskRef, {
                 limit: flags.limit,
                 cursor: flags.cursor,
             });

package/dist/commands/tasks/comments/reopen.js

@@ -19,10 +19,11 @@ class TasksCommentsReopen extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksCommentsReopen);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         let result;
         try {
             result = await data_provider_1.dataService.reopenTaskComment({
-                taskId: args.id,
+                taskId: taskRef,
                 commentId: args.commentId,
             });
         }
@@ -34,7 +35,7 @@ class TasksCommentsReopen extends base_command_1.BaseCommand {
             return;
         }
         const c = result;
-        this.log(`Reopened comment ${c.id ?? c._id ?? args.commentId} on task ${args.id}`);
+        this.log(`Reopened comment ${c.id ?? c._id ?? args.commentId} on task ${taskRef}`);
     }
 }
 exports.default = TasksCommentsReopen;

package/dist/commands/tasks/comments/resolve.js

@@ -19,10 +19,11 @@ class TasksCommentsResolve extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksCommentsResolve);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         let result;
         try {
             result = await data_provider_1.dataService.resolveTaskComment({
-                taskId: args.id,
+                taskId: taskRef,
                 commentId: args.commentId,
             });
         }
@@ -34,7 +35,7 @@ class TasksCommentsResolve extends base_command_1.BaseCommand {
             return;
         }
         const c = result;
-        this.log(`Resolved comment ${c.id ?? c._id ?? args.commentId} on task ${args.id}`);
+        this.log(`Resolved comment ${c.id ?? c._id ?? args.commentId} on task ${taskRef}`);
     }
 }
 exports.default = TasksCommentsResolve;

package/dist/commands/tasks/create-tree.d.ts

@@ -9,6 +9,68 @@ export type PlannedNode = {
     node: TreeNode;
     payload: TaskRecord;
 };
+/**
+ * Nodes a re-run could not recognize: no externalKey of their own and no
+ * `--external-key-prefix` to derive one. Re-running a partly applied tree
+ * creates these twice.
+ */
+export declare function unkeyedNodes(planned: PlannedNode[]): string[];
+export declare function rerunWarning(planned: PlannedNode[], prefix: string | undefined): {
+    code: string;
+    value: string[];
+    hint: string;
+} | undefined;
+/**
+ * A key prefix derived from the tree itself (its JSON plus the default scope),
+ * stable across runs: the same file into the same space always names the same
+ * keys. Different content or a different default space is a different prefix.
+ */
+export declare function derivedTreePrefix(input: TaskRecord, defaults: TaskRecord): string;
+export declare function derivedPrefixWarning(prefix: string): {
+    code: string;
+    value: string;
+    hint: string;
+};
+export type TreeFailure = {
+    tempId: string;
+    parentTempId?: string;
+    title?: unknown;
+    error: {
+        message: string;
+        status?: number;
+        code?: string;
+        retryable: boolean;
+    };
+};
+/**
+ * What a half-applied tree reports (E4). The ids already created are the only
+ * way to continue or clean up, and the failing call used to print none of them.
+ */
+export declare function partialFailureResult(args: {
+    results: Array<Record<string, unknown>>;
+    mapping: Record<string, string>;
+    failedAt: TreeFailure;
+    total: number;
+    prefix?: string;
+    warnings: Array<Record<string, unknown>>;
+}): {
+    warnings?: Record<string, unknown>[] | undefined;
+    object: string;
+    ok: boolean;
+    count: number;
+    total: number;
+    created: {
+        tempId: unknown;
+        parentTempId: unknown;
+        id: unknown;
+        action: unknown;
+        externalKey: unknown;
+        title: unknown;
+    }[];
+    mapping: Record<string, string>;
+    failedAt: TreeFailure;
+    rerun: string;
+};
 export default class TasksCreateTree extends BaseCommand {
     static description: string;
     static examples: string[];
@@ -17,6 +79,7 @@ export default class TasksCreateTree extends BaseCommand {
         'from-json': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
         'dry-run': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         'external-key-prefix': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        fresh: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         'default-agent': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         space: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         goal: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;