@pikku/cli 0.12.144 → 0.12.151

package/dist/src/fabric/fabric-commands.js

@@ -43,6 +43,12 @@ import { FabricDomainsList } from './functions/domains-list.function.js';
 import { FabricDomainsAdd } from './functions/domains-add.function.js';
 import { FabricDomainsRemove } from './functions/domains-remove.function.js';
 import { FabricLLMKey, renderLLMKey } from './functions/llm-key.function.js';
+import { FabricChangesList, renderChangesList, } from './functions/changes-list.function.js';
+import { FabricChangesShow, renderChangesShow, } from './functions/changes-show.function.js';
+import { FabricChangesClaim, renderChangesClaim, } from './functions/changes-claim.function.js';
+import { FabricChangesAsk, renderChangesAsk, } from './functions/changes-ask.function.js';
+import { FabricChangesShot, renderChangesShot, } from './functions/changes-shot.function.js';
+import { FabricChangesDone, renderChangesDone, } from './functions/changes-done.function.js';
 import { FabricValidate, renderValidate, } from './functions/validate.function.js';
 import { FabricSmoke, renderSmoke } from './functions/smoke.function.js';
 import { FabricPublish } from './functions/publish.function.js';
@@ -475,6 +481,135 @@ export const fabricCommands = defineCLICommands({
             }),
         },
     },
+    changes: {
+        description: 'The todo list filed from inside a deployed stage: read what is open, claim a batch, ask what you need to know, and tick items off',
+        subcommands: {
+            list: pikkuCLICommand({
+                func: FabricChangesList,
+                render: renderChangesList,
+                description: 'Open changes for a project, grouped the way they will be worked',
+                options: {
+                    projectId: {
+                        description: 'Project to read (defaults to the linked checkout)',
+                        short: 'p',
+                    },
+                    stageId: { description: 'Only changes filed on this stage' },
+                    route: {
+                        description: 'Only changes filed on this route, e.g. /checkout',
+                    },
+                    groupId: { description: 'Only changes in this group' },
+                    pickupOnly: {
+                        description: 'Skip items still held for the person who just filed them',
+                        default: false,
+                    },
+                    includeDone: {
+                        description: 'Also return done and dismissed items',
+                        default: false,
+                    },
+                    limit: {
+                        description: 'How many to return (default 50, max 200)',
+                        type: 'number',
+                    },
+                    apiUrl: { description: 'Override the fabric-api URL for this call' },
+                },
+            }),
+            show: pikkuCLICommand({
+                func: FabricChangesShow,
+                render: renderChangesShow,
+                description: 'One change with its thread, its circled elements and the build it was filed against',
+                options: {
+                    changeId: {
+                        description: 'The change to read, from `pikku fabric changes list`',
+                    },
+                    apiUrl: { description: 'Override the fabric-api URL for this call' },
+                },
+            }),
+            claim: pikkuCLICommand({
+                func: FabricChangesClaim,
+                render: renderChangesClaim,
+                description: 'Take a batch of items as one job under a lease. Naming items without a group creates the group',
+                options: {
+                    projectId: {
+                        description: 'Project the items belong to',
+                        short: 'p',
+                    },
+                    groupId: {
+                        description: 'Claim an existing group instead of forming one',
+                    },
+                    changeIds: {
+                        description: 'The items to take, comma-separated or repeated',
+                        type: 'string[]',
+                    },
+                    title: { description: 'What to call the group being formed' },
+                    claimedBy: {
+                        description: 'Who is taking it — shown in the panel while the lease is held',
+                    },
+                    leaseMinutes: {
+                        description: 'How long to hold it before it returns to the queue (default 30)',
+                        type: 'number',
+                    },
+                    apiUrl: { description: 'Override the fabric-api URL for this call' },
+                },
+            }),
+            ask: pikkuCLICommand({
+                func: FabricChangesAsk,
+                render: renderChangesAsk,
+                description: 'Ask the person who filed an item what you need to know. The question is parked, not blocking',
+                options: {
+                    changeId: { description: 'The item the question is about' },
+                    question: {
+                        description: 'One decision, in the filer’s vocabulary, with the options named',
+                        short: 'q',
+                    },
+                    authorName: { description: 'Who is asking, e.g. claude-code' },
+                    apiUrl: { description: 'Override the fabric-api URL for this call' },
+                },
+            }),
+            shot: pikkuCLICommand({
+                func: FabricChangesShot,
+                render: renderChangesShot,
+                description: 'Attach a rendered option to an item’s thread. The panel turns a set of them into a pick-one',
+                options: {
+                    changeId: { description: 'The item the options belong to' },
+                    label: {
+                        description: 'What to call this variant in the picker, e.g. “Grouped totals”',
+                    },
+                    image: { description: 'Path to the image file to attach' },
+                    imageBase64: {
+                        description: 'The image itself, base64, instead of --image',
+                    },
+                    contentType: {
+                        description: 'image/png, image/jpeg or image/webp (inferred from --image)',
+                    },
+                    kind: {
+                        description: 'option (a variant to choose between) or evidence (something to look at)',
+                        default: 'option',
+                    },
+                    authorName: { description: 'Who rendered it, e.g. claude-code' },
+                    apiUrl: { description: 'Override the fabric-api URL for this call' },
+                },
+            }),
+            done: pikkuCLICommand({
+                func: FabricChangesDone,
+                render: renderChangesDone,
+                description: 'Tick an item off, recording the branch and commit that closed it so the panel can strike it through',
+                options: {
+                    changeId: { description: 'The item that is done' },
+                    branch: {
+                        description: 'Branch the fix landed on (defaults to this checkout)',
+                    },
+                    headCommit: {
+                        description: 'Commit that closed it (defaults to this checkout)',
+                    },
+                    note: {
+                        description: 'What was done, for whoever reads the thread later',
+                    },
+                    authorName: { description: 'Who did it, e.g. claude-code' },
+                    apiUrl: { description: 'Override the fabric-api URL for this call' },
+                },
+            }),
+        },
+    },
     llm: {
         description: 'Fabric AI gateway developer key commands',
         subcommands: {

package/dist/src/fabric/functions/add.function.d.ts

@@ -29,7 +29,7 @@ export declare const FabricAdd: import("../../../.pikku/function/pikku-function-
     name: string;
     version: string;
     path: string;
-}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionSessionless<{
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
     id: string;
     dir?: string | undefined;
     apiUrl?: string | undefined;
@@ -38,7 +38,7 @@ export declare const FabricAdd: import("../../../.pikku/function/pikku-function-
     name: string;
     version: string;
     path: string;
-}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown> | import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices> | import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionSessionless<{
     id: string;
     dir?: string | undefined;
     apiUrl?: string | undefined;
@@ -47,4 +47,4 @@ export declare const FabricAdd: import("../../../.pikku/function/pikku-function-
     name: string;
     version: string;
     path: string;
-}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices>, undefined, undefined>;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown>, undefined, undefined>;

package/dist/src/fabric/functions/addon-verify.function.d.ts

@@ -19,36 +19,36 @@ export declare const FabricAddonVerify: import("../../../.pikku/function/pikku-f
 }, {
     ok: boolean;
     addonDir: string;
+    packageName?: string | undefined;
+    version?: string | undefined;
     checks: {
         name: string;
         ok: boolean;
         detail?: string | undefined;
     }[];
-    packageName?: string | undefined;
-    version?: string | undefined;
-}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionSessionless<{
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
     dir?: string | undefined;
 }, {
     ok: boolean;
     addonDir: string;
+    packageName?: string | undefined;
+    version?: string | undefined;
     checks: {
         name: string;
         ok: boolean;
         detail?: string | undefined;
     }[];
-    packageName?: string | undefined;
-    version?: string | undefined;
-}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown> | import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices> | import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionSessionless<{
     dir?: string | undefined;
 }, {
     ok: boolean;
     addonDir: string;
+    packageName?: string | undefined;
+    version?: string | undefined;
     checks: {
         name: string;
         ok: boolean;
         detail?: string | undefined;
     }[];
-    packageName?: string | undefined;
-    version?: string | undefined;
-}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices>, undefined, undefined>;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown>, undefined, undefined>;
 export declare function renderAddonVerify(_s: unknown, result: FabricAddonVerifyOutput): void;

package/dist/src/fabric/functions/changes-ask.function.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import type { AskChangeQuestionOutput } from '../sdk/rpc-map.gen.d.js';
+export declare const FabricChangesAskInput: z.ZodObject<{
+    apiUrl: z.ZodOptional<z.ZodString>;
+    changeId: z.ZodString;
+    question: z.ZodString;
+    authorName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const FabricChangesAskOutput: z.ZodObject<{
+    message: z.ZodAny;
+}, z.core.$strip>;
+export declare const FabricChangesAsk: import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionConfig<{
+    apiUrl?: string | undefined;
+    changeId: string;
+    question: string;
+    authorName?: string | undefined;
+}, {
+    message: any;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
+    apiUrl?: string | undefined;
+    changeId: string;
+    question: string;
+    authorName?: string | undefined;
+}, {
+    message: any;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices> | import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionSessionless<{
+    apiUrl?: string | undefined;
+    changeId: string;
+    question: string;
+    authorName?: string | undefined;
+}, {
+    message: any;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown>, undefined, undefined>;
+export declare const renderChangesAsk: (_s: unknown, { message }: AskChangeQuestionOutput) => void;

package/dist/src/fabric/functions/changes-ask.function.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
+import { changesContext } from '../lib/changes.js';
+import { dim, safeBlock } from '../lib/output.js';
+export const FabricChangesAskInput = z.object({
+    apiUrl: z.string().optional(),
+    changeId: z.string(),
+    question: z.string().trim().min(1, 'Ask something — the question is empty.'),
+    authorName: z.string().optional(),
+});
+export const FabricChangesAskOutput = z.object({
+    message: z.any(),
+});
+export const FabricChangesAsk = pikkuSessionlessFunc({
+    description: 'Ask the person who filed a change what you need to know.',
+    input: FabricChangesAskInput,
+    output: FabricChangesAskOutput,
+    func: async (_services, input) => {
+        const { rpc } = await changesContext(input.apiUrl);
+        return await rpc.invoke('askChangeQuestion', {
+            changeId: input.changeId,
+            question: input.question,
+            authorName: input.authorName ?? 'pikku-cli',
+        });
+    },
+});
+export const renderChangesAsk = (_s, { message }) => {
+    console.log('Asked — the item now shows as needing an answer in the panel.');
+    console.log(dim(`  ${safeBlock(message.body)}`));
+};

package/dist/src/fabric/functions/changes-claim.function.d.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import type { ClaimChangesOutput } from '../sdk/rpc-map.gen.d.js';
+export declare const FabricChangesClaimInput: z.ZodObject<{
+    apiUrl: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    groupId: z.ZodOptional<z.ZodString>;
+    changeIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    title: z.ZodOptional<z.ZodString>;
+    claimedBy: z.ZodOptional<z.ZodString>;
+    leaseMinutes: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const FabricChangesClaimOutput: z.ZodObject<{
+    group: z.ZodAny;
+    changes: z.ZodAny;
+}, z.core.$strip>;
+export declare const FabricChangesClaim: import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionConfig<{
+    apiUrl?: string | undefined;
+    projectId?: string | undefined;
+    groupId?: string | undefined;
+    changeIds?: string[] | undefined;
+    title?: string | undefined;
+    claimedBy?: string | undefined;
+    leaseMinutes?: number | undefined;
+}, {
+    group: any;
+    changes: any;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
+    apiUrl?: string | undefined;
+    projectId?: string | undefined;
+    groupId?: string | undefined;
+    changeIds?: string[] | undefined;
+    title?: string | undefined;
+    claimedBy?: string | undefined;
+    leaseMinutes?: number | undefined;
+}, {
+    group: any;
+    changes: any;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices> | import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionSessionless<{
+    apiUrl?: string | undefined;
+    projectId?: string | undefined;
+    groupId?: string | undefined;
+    changeIds?: string[] | undefined;
+    title?: string | undefined;
+    claimedBy?: string | undefined;
+    leaseMinutes?: number | undefined;
+}, {
+    group: any;
+    changes: any;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown>, undefined, undefined>;
+export declare const renderChangesClaim: (_s: unknown, { group, changes }: ClaimChangesOutput) => void;

package/dist/src/fabric/functions/changes-claim.function.js

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
+import { changesContext, idList, requireProjectId } from '../lib/changes.js';
+import { dim, safe } from '../lib/output.js';
+export const FabricChangesClaimInput = z.object({
+    apiUrl: z.string().optional(),
+    projectId: z.string().optional(),
+    groupId: z.string().optional(),
+    changeIds: z.array(z.string()).optional(),
+    title: z.string().optional(),
+    claimedBy: z.string().optional(),
+    leaseMinutes: z.number().optional(),
+});
+export const FabricChangesClaimOutput = z.object({
+    group: z.any(),
+    changes: z.any(),
+});
+export const FabricChangesClaim = pikkuSessionlessFunc({
+    description: 'Take a batch of changes as one job under a lease.',
+    input: FabricChangesClaimInput,
+    output: FabricChangesClaimOutput,
+    func: async (_services, input) => {
+        const { rpc, projectId } = await changesContext(input.apiUrl, input.projectId);
+        return await rpc.invoke('claimChanges', {
+            projectId: requireProjectId(projectId),
+            groupId: input.groupId,
+            changeIds: idList(input.changeIds),
+            title: input.title,
+            claimedBy: input.claimedBy ?? 'pikku-cli',
+            leaseMinutes: input.leaseMinutes ?? 30,
+        });
+    },
+});
+export const renderChangesClaim = (_s, { group, changes }) => {
+    console.log(`Claimed ${changes.length} item(s) as “${safe(group.title)}”`);
+    console.log(dim(`group ${safe(group.groupId)}`));
+    if (group.claimExpiresAt) {
+        console.log(dim(`lease until ${new Date(group.claimExpiresAt).toISOString()}`));
+    }
+    for (const change of changes) {
+        console.log(`  #${safe(change.shortId)}  ${safe(change.title)}  ${dim(safe(change.changeId))}`);
+    }
+};

package/dist/src/fabric/functions/changes-done.function.d.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import type { CompleteChangeOutput } from '../sdk/rpc-map.gen.d.js';
+export declare const FabricChangesDoneInput: z.ZodObject<{
+    apiUrl: z.ZodOptional<z.ZodString>;
+    changeId: z.ZodString;
+    branch: z.ZodOptional<z.ZodString>;
+    headCommit: z.ZodOptional<z.ZodString>;
+    note: z.ZodOptional<z.ZodString>;
+    authorName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const FabricChangesDoneOutput: z.ZodObject<{
+    change: z.ZodAny;
+}, z.core.$strip>;
+/**
+ * `rev-parse --abbrev-ref HEAD` answers the literal 'HEAD' in a detached
+ * checkout. Recording that would strike the item through against a branch
+ * nobody can open, so it is dropped — the sha read alongside it is still real,
+ * and is enough to say where the fix landed.
+ */
+export declare const namedBranch: (head: string) => string | undefined;
+/**
+ * Branch and commit default to the checkout this runs in. They are what strikes
+ * the item through on the page it was filed from, and a hand-typed sha that
+ * does not exist points the filer at nothing — so read them from git unless the
+ * caller has a reason to say otherwise.
+ */
+export declare const FabricChangesDone: import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionConfig<{
+    apiUrl?: string | undefined;
+    changeId: string;
+    branch?: string | undefined;
+    headCommit?: string | undefined;
+    note?: string | undefined;
+    authorName?: string | undefined;
+}, {
+    change: any;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
+    apiUrl?: string | undefined;
+    changeId: string;
+    branch?: string | undefined;
+    headCommit?: string | undefined;
+    note?: string | undefined;
+    authorName?: string | undefined;
+}, {
+    change: any;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices> | import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionSessionless<{
+    apiUrl?: string | undefined;
+    changeId: string;
+    branch?: string | undefined;
+    headCommit?: string | undefined;
+    note?: string | undefined;
+    authorName?: string | undefined;
+}, {
+    change: any;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown>, undefined, undefined>;
+export declare const renderChangesDone: (_s: unknown, { change }: CompleteChangeOutput) => void;

package/dist/src/fabric/functions/changes-done.function.js

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
+import { changesContext } from '../lib/changes.js';
+import { currentBranch, headSha, isGitRepo } from '../lib/git.js';
+import { dim, safe } from '../lib/output.js';
+export const FabricChangesDoneInput = z.object({
+    apiUrl: z.string().optional(),
+    changeId: z.string(),
+    branch: z.string().optional(),
+    headCommit: z.string().optional(),
+    note: z.string().optional(),
+    authorName: z.string().optional(),
+});
+export const FabricChangesDoneOutput = z.object({
+    change: z.any(),
+});
+/**
+ * `rev-parse --abbrev-ref HEAD` answers the literal 'HEAD' in a detached
+ * checkout. Recording that would strike the item through against a branch
+ * nobody can open, so it is dropped — the sha read alongside it is still real,
+ * and is enough to say where the fix landed.
+ */
+export const namedBranch = (head) => head === 'HEAD' || head === '' ? undefined : head;
+/**
+ * Branch and commit default to the checkout this runs in. They are what strikes
+ * the item through on the page it was filed from, and a hand-typed sha that
+ * does not exist points the filer at nothing — so read them from git unless the
+ * caller has a reason to say otherwise.
+ */
+export const FabricChangesDone = pikkuSessionlessFunc({
+    description: 'Tick a change off, recording the commit that closed it.',
+    input: FabricChangesDoneInput,
+    output: FabricChangesDoneOutput,
+    func: async (_services, input) => {
+        let branch = input.branch;
+        let headCommit = input.headCommit;
+        if ((!branch || !headCommit) && (await isGitRepo())) {
+            branch ??= await currentBranch()
+                .then(namedBranch)
+                .catch(() => undefined);
+            headCommit ??= await headSha().catch(() => undefined);
+        }
+        const { rpc } = await changesContext(input.apiUrl);
+        return await rpc.invoke('completeChange', {
+            changeId: input.changeId,
+            branch,
+            headCommit,
+            note: input.note,
+            authorName: input.authorName ?? 'pikku-cli',
+        });
+    },
+});
+export const renderChangesDone = (_s, { change }) => {
+    const at = [change.branch, change.headCommit?.slice(0, 7)]
+        .map((part) => (part ? safe(part) : part))
+        .filter(Boolean)
+        .join(' @ ');
+    console.log(`#${safe(change.shortId)} done${at ? dim(`  ${at}`) : ''}`);
+};

package/dist/src/fabric/functions/changes-list.function.d.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import type { ListChangesOutput } from '../sdk/rpc-map.gen.d.js';
+export declare const FabricChangesListInput: z.ZodObject<{
+    apiUrl: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    stageId: z.ZodOptional<z.ZodString>;
+    route: z.ZodOptional<z.ZodString>;
+    groupId: z.ZodOptional<z.ZodString>;
+    pickupOnly: z.ZodOptional<z.ZodBoolean>;
+    includeDone: z.ZodOptional<z.ZodBoolean>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const FabricChangesListOutput: z.ZodObject<{
+    changes: z.ZodAny;
+    groups: z.ZodAny;
+}, z.core.$strip>;
+export declare const FabricChangesList: import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionConfig<{
+    apiUrl?: string | undefined;
+    projectId?: string | undefined;
+    stageId?: string | undefined;
+    route?: string | undefined;
+    groupId?: string | undefined;
+    pickupOnly?: boolean | undefined;
+    includeDone?: boolean | undefined;
+    limit?: number | undefined;
+}, {
+    changes: any;
+    groups: any;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
+    apiUrl?: string | undefined;
+    projectId?: string | undefined;
+    stageId?: string | undefined;
+    route?: string | undefined;
+    groupId?: string | undefined;
+    pickupOnly?: boolean | undefined;
+    includeDone?: boolean | undefined;
+    limit?: number | undefined;
+}, {
+    changes: any;
+    groups: any;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices> | import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionSessionless<{
+    apiUrl?: string | undefined;
+    projectId?: string | undefined;
+    stageId?: string | undefined;
+    route?: string | undefined;
+    groupId?: string | undefined;
+    pickupOnly?: boolean | undefined;
+    includeDone?: boolean | undefined;
+    limit?: number | undefined;
+}, {
+    changes: any;
+    groups: any;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown>, undefined, undefined>;
+type Change = ListChangesOutput['changes'][number];
+type Group = ListChangesOutput['groups'][number];
+export declare const renderChangesList: (_s: unknown, { changes, groups }: {
+    changes: Change[];
+    groups: Group[];
+}) => void;
+export {};

package/dist/src/fabric/functions/changes-list.function.js

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
+import { age, changesContext, remaining, requireProjectId, } from '../lib/changes.js';
+import { dim, safe, statusColor } from '../lib/output.js';
+export const FabricChangesListInput = z.object({
+    apiUrl: z.string().optional(),
+    projectId: z.string().optional(),
+    stageId: z.string().optional(),
+    route: z.string().optional(),
+    groupId: z.string().optional(),
+    pickupOnly: z.boolean().optional(),
+    includeDone: z.boolean().optional(),
+    limit: z.number().optional(),
+});
+export const FabricChangesListOutput = z.object({
+    changes: z.any(),
+    groups: z.any(),
+});
+export const FabricChangesList = pikkuSessionlessFunc({
+    description: 'List the open changes filed against a project.',
+    input: FabricChangesListInput,
+    output: FabricChangesListOutput,
+    func: async (_services, input) => {
+        const { rpc, projectId } = await changesContext(input.apiUrl, input.projectId);
+        return await rpc.invoke('listChanges', {
+            projectId: requireProjectId(projectId),
+            stageId: input.stageId,
+            route: input.route,
+            groupId: input.groupId,
+            pickupOnly: input.pickupOnly ?? false,
+            includeDone: input.includeDone ?? false,
+            limit: input.limit ?? 50,
+        });
+    },
+});
+const line = (change) => {
+    const flags = [
+        statusColor(change.status),
+        change.held ? dim('held') : null,
+        change.route ? safe(change.route) : null,
+    ]
+        .filter(Boolean)
+        .join('  ');
+    console.log(`  #${safe(change.shortId)}  ${safe(change.title)}`);
+    console.log(`      ${flags}  ${age(change.createdAt)} ago  ${dim(safe(change.changeId))}`);
+    const named = (change.capture?.elements ?? [])
+        .map((element) => element.testId ?? element.sourceAnchor ?? element.cssPath)
+        .filter((name) => !!name)
+        .map(safe);
+    if (named.length)
+        console.log(dim(`      circled: ${named.join(', ')}`));
+};
+export const renderChangesList = (_s, { changes, groups }) => {
+    if (!changes.length) {
+        console.log(dim('  Nothing open.'));
+        return;
+    }
+    const listed = new Set(groups.map((group) => group.groupId));
+    const ungrouped = changes.filter((change) => !change.groupId);
+    const grouped = changes.filter((change) => change.groupId);
+    if (ungrouped.length) {
+        console.log(`unclaimed (${ungrouped.length})`);
+        ungrouped.forEach(line);
+    }
+    for (const group of groups) {
+        const members = grouped.filter((change) => change.groupId === group.groupId);
+        if (!members.length)
+            continue;
+        const lease = group.claimedBy && group.claimExpiresAt
+            ? `claimed by ${safe(group.claimedBy)}, ${remaining(group.claimExpiresAt)} left`
+            : 'unclaimed';
+        console.log('');
+        console.log(`${safe(group.title)}  ${dim(`(${lease})  ${safe(group.groupId)}`)}`);
+        members.forEach(line);
+    }
+    const orphaned = grouped.filter((change) => !listed.has(change.groupId));
+    if (orphaned.length) {
+        console.log('');
+        console.log(dim('grouped, group not listed'));
+        orphaned.forEach(line);
+    }
+};