@pikku/cli 0.12.145 → 0.12.152

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

@@ -43,6 +43,13 @@ 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 { FabricChangesFile, renderChangesFile, } from './functions/changes-file.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 +482,165 @@ export const fabricCommands = defineCLICommands({
             }),
         },
     },
+    changes: {
+        description: 'The todo list filed from inside a deployed stage: read what is open, file what was decided elsewhere, 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' },
+                },
+            }),
+            file: pikkuCLICommand({
+                func: FabricChangesFile,
+                render: renderChangesFile,
+                description: 'File an item from outside the panel — the words, without the screenshot the panel would have attached',
+                options: {
+                    projectId: {
+                        description: 'Project to file against (defaults to the linked checkout)',
+                        short: 'p',
+                    },
+                    stageId: {
+                        description: 'Stage to file against (defaults to the only stage)',
+                    },
+                    branch: {
+                        description: 'Resolve the stage from this branch instead',
+                    },
+                    title: {
+                        description: 'The requirement, in one line',
+                        short: 't',
+                    },
+                    body: { description: 'The detail, if a line is not enough' },
+                    bodyFile: {
+                        description: 'Read the body from a file — use this when it has newlines',
+                    },
+                    route: {
+                        description: 'The route it is about, e.g. /admin/rota',
+                    },
+                    locale: { description: 'Locale it was seen in, e.g. de' },
+                    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-file.function.d.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import type { CreateChangeOutput } from '../sdk/rpc-map.gen.d.js';
+export declare const FabricChangesFileInput: z.ZodObject<{
+    apiUrl: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    stageId: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    body: z.ZodOptional<z.ZodString>;
+    bodyFile: z.ZodOptional<z.ZodString>;
+    route: z.ZodOptional<z.ZodString>;
+    locale: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const FabricChangesFileOutput: z.ZodObject<{
+    change: z.ZodAny;
+}, z.core.$strip>;
+/**
+ * An item filed from a terminal carries no screenshot, no circled elements and
+ * no build — the panel supplies those and nothing here can invent them. What it
+ * does carry is the words, which the skill already treats as the requirement
+ * and every other address as evidence, so a written item is a thinner but not a
+ * malformed one.
+ *
+ * `--body-file` because a real item's body is a paragraph with newlines in it,
+ * and putting that through shell quoting is where it gets mangled.
+ */
+export declare const FabricChangesFile: import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionConfig<{
+    apiUrl?: string | undefined;
+    projectId?: string | undefined;
+    stageId?: string | undefined;
+    branch?: string | undefined;
+    title: string;
+    body?: string | undefined;
+    bodyFile?: string | undefined;
+    route?: string | undefined;
+    locale?: string | undefined;
+}, {
+    change: any;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunction<{
+    apiUrl?: string | undefined;
+    projectId?: string | undefined;
+    stageId?: string | undefined;
+    branch?: string | undefined;
+    title: string;
+    body?: string | undefined;
+    bodyFile?: string | undefined;
+    route?: string | undefined;
+    locale?: 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;
+    projectId?: string | undefined;
+    stageId?: string | undefined;
+    branch?: string | undefined;
+    title: string;
+    body?: string | undefined;
+    bodyFile?: string | undefined;
+    route?: string | undefined;
+    locale?: string | undefined;
+}, {
+    change: any;
+}, "rpc" | "session", import("../../../.pikku/function/pikku-function-types.gen.js").WiredServices, unknown>, undefined, undefined>;
+export declare const renderChangesFile: (_s: unknown, { change }: CreateChangeOutput) => void;

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

@@ -0,0 +1,56 @@
+import { readFile } from 'node:fs/promises';
+import { z } from 'zod';
+import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
+import { changesContext, requireProjectId } from '../lib/changes.js';
+import { resolveStageId } from '../lib/stage.js';
+import { dim, safe } from '../lib/output.js';
+export const FabricChangesFileInput = z.object({
+    apiUrl: z.string().optional(),
+    projectId: z.string().optional(),
+    stageId: z.string().optional(),
+    branch: z.string().optional(),
+    title: z.string().trim().min(1, 'Give the item a title.'),
+    body: z.string().optional(),
+    bodyFile: z.string().optional(),
+    route: z.string().optional(),
+    locale: z.string().optional(),
+});
+export const FabricChangesFileOutput = z.object({
+    change: z.any(),
+});
+/**
+ * An item filed from a terminal carries no screenshot, no circled elements and
+ * no build — the panel supplies those and nothing here can invent them. What it
+ * does carry is the words, which the skill already treats as the requirement
+ * and every other address as evidence, so a written item is a thinner but not a
+ * malformed one.
+ *
+ * `--body-file` because a real item's body is a paragraph with newlines in it,
+ * and putting that through shell quoting is where it gets mangled.
+ */
+export const FabricChangesFile = pikkuSessionlessFunc({
+    description: 'File a change against a stage from outside the panel.',
+    input: FabricChangesFileInput,
+    output: FabricChangesFileOutput,
+    func: async (_services, input) => {
+        if (input.body && input.bodyFile)
+            throw new Error('Pass --body or --body-file, not both.');
+        const { rpc, projectId } = await changesContext(input.apiUrl, input.projectId);
+        const stageId = input.stageId ??
+            (await resolveStageId(rpc, requireProjectId(projectId), input.branch));
+        const body = input.bodyFile
+            ? await readFile(input.bodyFile, 'utf8')
+            : input.body;
+        return await rpc.invoke('createChange', {
+            stageId,
+            title: input.title,
+            body: body?.trim() || undefined,
+            route: input.route,
+            locale: input.locale,
+        });
+    },
+});
+export const renderChangesFile = (_s, { change }) => {
+    console.log(`Filed #${safe(change.shortId)}  ${safe(change.title)}`);
+    console.log(dim(`  ${safe(change.changeId)}`));
+};