@skrr-ai/cli 0.1.8

package/dist/commands/wiki/update.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+const wiki_1 = require("../../lib/wiki");
+const wiki_update_1 = require("../../lib/wiki-update");
+/**
+ * `skrr wiki update <space> <path>` — a page's METADATA: title, icon, order.
+ *
+ * Distinct from `mv`, which owns the page's PATH, and from `write`, which owns
+ * its body. That split follows the server: retitling deliberately keeps the
+ * slug (`keepSlug` in the wiki controller), because a path an agent stored
+ * must not break just because a human improved the heading. So `--title` here
+ * never moves the page, and there is no `--slug` — renaming the path is what
+ * `mv` is for, and two commands that both rewrite a slug is how they drift.
+ */
+class WikiUpdate extends base_command_1.BaseCommand {
+    static description = "Update a wiki page's title, icon, or sort order";
+    static examples = [
+        '<%= config.bin %> wiki update <space-id> Engineering/deploy --title "Deploy Runbook"',
+        '<%= config.bin %> wiki update <space-id> Engineering/deploy --icon 🚀',
+        '<%= config.bin %> wiki update <space-id> Engineering/deploy --clear-icon',
+        '<%= config.bin %> wiki update <space-id> Engineering/deploy --order 0 --json',
+    ];
+    static args = {
+        space: core_1.Args.string({ description: 'Space ID', required: true, ignoreStdin: true }),
+        path: core_1.Args.string({ description: 'Page path', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        title: core_1.Flags.string({
+            description: 'New title. The page keeps its slug, so stored paths stay valid.',
+        }),
+        icon: core_1.Flags.string({ description: 'Emoji or short icon token', exclusive: ['clear-icon'] }),
+        'clear-icon': core_1.Flags.boolean({
+            description: 'Remove the icon (an empty --icon would be a validation error, not a clear)',
+            exclusive: ['icon'],
+        }),
+        order: core_1.Flags.integer({ description: 'Sort position within its folder (0-based)' }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(WikiUpdate);
+        const path = (0, wiki_1.normalizeWikiPath)(args.path);
+        if (!path) {
+            this.failWithCliError({
+                message: 'Name the page to update.',
+                code: 'WIKI_PATH_REQUIRED',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        const built = (0, wiki_update_1.buildWikiPageUpdate)({
+            title: flags.title,
+            icon: flags.icon,
+            clearIcon: flags['clear-icon'],
+            order: flags.order,
+        });
+        if (!built.ok) {
+            this.failWithCliError({
+                message: built.error,
+                code: 'WIKI_UPDATE_EMPTY',
+                exit: 2,
+                retryable: false,
+            });
+        }
+        const data = built.data;
+        let page;
+        try {
+            page = await data_provider_1.dataService.getSpaceWikiPageByPath(args.space, path);
+        }
+        catch (err) {
+            this.handleApiError(err, { subject: `wiki page ${path}` });
+        }
+        let updated;
+        try {
+            updated = await data_provider_1.dataService.updateSpaceWikiPage({
+                spaceId: args.space,
+                pageId: page.pageId,
+                data,
+            });
+        }
+        catch (err) {
+            this.handleApiError(err, { subject: `wiki page ${path}` });
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(updated, null, 2));
+            return;
+        }
+        this.log(`Updated ${updated.path ?? path} (${Object.keys(data).join(', ')}).`);
+    }
+}
+exports.default = WikiUpdate;

package/dist/commands/wiki/write.d.ts

@@ -0,0 +1,55 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * The page lookup below goes through `dataService`, whose adapter throws a
+ * plain `Error` carrying `status` — not an `ApiFetchError` and not an
+ * Axios-shaped `{ response: { status } }`. Matching on either of those shapes
+ * (as this did) makes every miss look like a hard failure, which left the
+ * create branch below permanently unreachable. `isHttpNotFound` reads the
+ * status structurally so all transports are covered.
+ */
+export declare function isWikiPageNotFound(err: unknown): boolean;
+/**
+ * A `409 WIKI_SLUG_CONFLICT` from the server's `conflict: 'fail'` create path,
+ * unwrapped to the id of the page that was already there.
+ *
+ * Returns `undefined` for anything else, INCLUDING a 409 whose body carried no
+ * id — an older or differently-shaped server. The caller must treat that as
+ * "not handled here" rather than as "no conflict".
+ */
+export declare function conflictingPageId(err: unknown): string | undefined;
+export declare function slugifyLikeServer(input: string): string;
+/**
+ * Did the server rename our page out from under us?
+ *
+ * A server that understands `conflict: 'fail'` answers 409 and we never get
+ * here. This is the fallback for an OLDER server, which de-duplicates a
+ * colliding slug by suffixing it (`x` -> `x-2`) and returns 201 — silently
+ * turning a create-or-overwrite write into a second page beside the original.
+ *
+ * The comparison must be against `slugify(requested)`, not `requested`. The
+ * server lowercases and collapses whitespace, so a raw comparison called every
+ * mixed-case path a duplicate: writing `README` produced slug `readme` and got
+ * reported as a collision that had not happened — with a message telling the
+ * user to delete the page they had just correctly created. Only an actual
+ * disambiguation suffix counts, so any OTHER normalization the server grows
+ * later reads as "no collision" rather than as a fresh false positive.
+ */
+export declare function createdSlugCollided(requestedSlug: string, createdSlug?: string): boolean;
+export default class WikiWrite extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        space: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        path: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        content: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        file: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        stdin: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        html: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        append: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        title: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/wiki/write.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWikiPageNotFound = isWikiPageNotFound;
+exports.conflictingPageId = conflictingPageId;
+exports.slugifyLikeServer = slugifyLikeServer;
+exports.createdSlugCollided = createdSlugCollided;
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+const http_error_1 = require("../../lib/http-error");
+const wiki_1 = require("../../lib/wiki");
+/**
+ * The page lookup below goes through `dataService`, whose adapter throws a
+ * plain `Error` carrying `status` — not an `ApiFetchError` and not an
+ * Axios-shaped `{ response: { status } }`. Matching on either of those shapes
+ * (as this did) makes every miss look like a hard failure, which left the
+ * create branch below permanently unreachable. `isHttpNotFound` reads the
+ * status structurally so all transports are covered.
+ */
+function isWikiPageNotFound(err) {
+    return (0, http_error_1.isHttpNotFound)(err);
+}
+/**
+ * A `409 WIKI_SLUG_CONFLICT` from the server's `conflict: 'fail'` create path,
+ * unwrapped to the id of the page that was already there.
+ *
+ * Returns `undefined` for anything else, INCLUDING a 409 whose body carried no
+ * id — an older or differently-shaped server. The caller must treat that as
+ * "not handled here" rather than as "no conflict".
+ */
+function conflictingPageId(err) {
+    if (!(0, http_error_1.hasHttpStatus)(err, 409))
+        return undefined;
+    const body = (0, http_error_1.httpBodyOf)(err);
+    if (body?.code !== 'WIKI_SLUG_CONFLICT')
+        return undefined;
+    return typeof body.pageId === 'string' && body.pageId ? body.pageId : undefined;
+}
+/**
+ * Mirror of the server's `slugify` (`api/models/WikiPage.js`). The comparison
+ * below is only meaningful against the name the SERVER would have derived, not
+ * against the raw argument the user typed — see `createdSlugCollided`.
+ *
+ * Duplicated rather than imported because it lives in an API-internal model
+ * with no published surface. `__tests__/write.spec.ts` pins the cases that
+ * matter; if the server's rules change, the fallback guard degrades to
+ * "reports nothing", never to "reports a false duplicate".
+ */
+const MAX_SLUG_LENGTH = 255;
+function slugifyLikeServer(input) {
+    const base = String(input || '')
+        .trim()
+        .toLowerCase()
+        .replace(/[/\\]+/g, '-')
+        // eslint-disable-next-line no-control-regex
+        .replace(/[\u0000-\u001f\u007f]/g, '')
+        .replace(/\s+/g, '-')
+        .replace(/-{2,}/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, MAX_SLUG_LENGTH);
+    return base || 'untitled';
+}
+/**
+ * Did the server rename our page out from under us?
+ *
+ * A server that understands `conflict: 'fail'` answers 409 and we never get
+ * here. This is the fallback for an OLDER server, which de-duplicates a
+ * colliding slug by suffixing it (`x` -> `x-2`) and returns 201 — silently
+ * turning a create-or-overwrite write into a second page beside the original.
+ *
+ * The comparison must be against `slugify(requested)`, not `requested`. The
+ * server lowercases and collapses whitespace, so a raw comparison called every
+ * mixed-case path a duplicate: writing `README` produced slug `readme` and got
+ * reported as a collision that had not happened — with a message telling the
+ * user to delete the page they had just correctly created. Only an actual
+ * disambiguation suffix counts, so any OTHER normalization the server grows
+ * later reads as "no collision" rather than as a fresh false positive.
+ */
+function createdSlugCollided(requestedSlug, createdSlug) {
+    if (!createdSlug || !requestedSlug)
+        return false;
+    const base = slugifyLikeServer(requestedSlug);
+    if (createdSlug === base)
+        return false;
+    if (!createdSlug.startsWith(`${base}-`))
+        return false;
+    const suffix = createdSlug.slice(base.length + 1);
+    // `allocateSlug` appends either an ordinal (`-2`) or, in its pathological
+    // fallback, an 8-char uuid head.
+    return /^\d+$/.test(suffix) || /^[0-9a-f]{8}$/.test(suffix);
+}
+class WikiWrite extends base_command_1.BaseCommand {
+    // The markdown dialect note lives here, not only in SKRR_WIKI.md: --help is the
+    // one place a CLI user (or an agent with no docs) looks before writing, and
+    // `__x__` silently staying literal is exactly the kind of surprise that has to
+    // reach them there. (OSK-4844)
+    static description = 'Write a wiki page, creating it (and any missing folders) if needed. ' +
+        'Markdown by default; `__x__` stays literal (use `**x**` for bold) and a ' +
+        'backslash before punctuation escapes it — see docs/cli/SKRR_WIKI.md.';
+    static examples = [
+        '<%= config.bin %> wiki write <space-id> Engineering/deploy --file runbook.md',
+        'cat notes.md | <%= config.bin %> wiki write <space-id> notes --stdin',
+        '<%= config.bin %> wiki write <space-id> log --content "Shipped v2" --append',
+    ];
+    static args = {
+        space: core_1.Args.string({ description: 'Space ID', required: true, ignoreStdin: true }),
+        path: core_1.Args.string({ description: 'Page path', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        content: core_1.Flags.string({ description: 'Content inline' }),
+        file: core_1.Flags.string({ char: 'f', description: 'Read content from a file ("-" for stdin)' }),
+        stdin: core_1.Flags.boolean({ description: 'Read content from stdin' }),
+        html: core_1.Flags.boolean({ description: 'Treat the input as HTML instead of Markdown' }),
+        append: core_1.Flags.boolean({ description: 'Append instead of replacing (>> rather than >)' }),
+        title: core_1.Flags.string({ description: 'Title for a newly-created page (defaults to the slug)' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(WikiWrite);
+        let content;
+        try {
+            content = await (0, wiki_1.readContentInput)({
+                content: flags.content,
+                file: flags.file,
+                stdin: flags.stdin,
+            });
+        }
+        catch (err) {
+            this.failWithCliError({
+                message: err.message,
+                code: 'WIKI_CONTENT_INPUT_REQUIRED',
+                exit: 1,
+                retryable: false,
+            });
+        }
+        const format = flags.html ? 'html' : 'markdown';
+        const mode = flags.append ? 'append' : 'replace';
+        // Create-or-write, so an agent never has to branch on existence. Look the
+        // page up first; a 404 means "create it", which also creates the folder
+        // chain via `folderPath` (mkdir -p).
+        let existing = null;
+        try {
+            existing = await data_provider_1.dataService.getSpaceWikiPageByPath(args.space, args.path);
+        }
+        catch (err) {
+            if (!isWikiPageNotFound(err)) {
+                this.handleApiError(err);
+            }
+        }
+        const { dir, name } = (0, wiki_1.splitParentPath)(args.path);
+        const writeInto = (pageId) => data_provider_1.dataService.writeSpaceWikiPageContent({
+            spaceId: args.space,
+            pageId,
+            data: { content, format, mode },
+        });
+        let page;
+        // `existing` decides which branch we OPEN with, never which one we end in:
+        // the lookup above can be stale (a CDN-cached 404 is the documented case),
+        // so the create below asks the server to refuse rather than rename, and a
+        // refusal is resolved by writing into whatever was really there.
+        let wroteIntoExisting = Boolean(existing);
+        try {
+            if (existing) {
+                page = await writeInto(existing.pageId);
+            }
+            else {
+                try {
+                    page = await data_provider_1.dataService.createSpaceWikiPage({
+                        spaceId: args.space,
+                        data: {
+                            title: flags.title || name,
+                            slug: name,
+                            folderPath: dir || undefined,
+                            content,
+                            format,
+                            // Never let the server rename an EXACTLY addressed path. Without
+                            // this it answers 201 having created `x-2` beside `x`, and the
+                            // write the user asked for silently did not happen.
+                            conflict: 'fail',
+                        },
+                    });
+                }
+                catch (err) {
+                    const conflictId = conflictingPageId(err);
+                    if (conflictId === undefined) {
+                        throw err;
+                    }
+                    // The page existed after all. This is the outcome the user asked
+                    // for, not an error — complete the write instead of reporting one.
+                    page = await writeInto(conflictId);
+                    wroteIntoExisting = true;
+                }
+            }
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        // Fallback for a server predating `conflict: 'fail'`, which answers 201
+        // with a renamed slug instead of 409. Unreachable against a current server.
+        if (!wroteIntoExisting && createdSlugCollided(name, page.slug)) {
+            this.failWithCliError({
+                message: `Wrote a DUPLICATE page: asked for '${args.path}' but the server already had that slug and created ` +
+                    `'${page.path ?? page.slug}' (${page.pageId}) beside it. The content did NOT overwrite the original.\n` +
+                    `This happens when the same path is written twice within ~10s: the first write's 404 lookup is cached ` +
+                    `by the CDN, so the second write cannot see the page it just made. Re-run in a moment to overwrite the ` +
+                    `original, and delete the duplicate with \`${this.config.bin} wiki rm ${args.space} ${page.path ?? page.slug}\`.`,
+                code: 'WIKI_DUPLICATE_PAGE_CREATED',
+                exit: 1,
+                retryable: true,
+                details: {
+                    requestedPath: args.path,
+                    requestedSlug: name,
+                    createdSlug: page.slug,
+                    duplicatePageId: page.pageId,
+                },
+            });
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(page, null, 2));
+            return;
+        }
+        // Report what actually happened, not what we set out to do — a write that
+        // landed via the 409 path updated a page, and calling that "Created" is the
+        // same lie the duplicate bug told.
+        let verb = 'Created';
+        if (wroteIntoExisting) {
+            verb = flags.append ? 'Appended to' : 'Updated';
+        }
+        this.log(`${verb} ${page.path ?? args.path} (${page.pageId}).`);
+    }
+}
+exports.default = WikiWrite;

package/dist/commands/work-views/create.d.ts

@@ -0,0 +1,31 @@
+import { BaseCommand } from '../../base-command';
+export declare const DEFAULT_WORK_VIEW_CONFIG: {
+    readonly schemaVersion: 1;
+    readonly timeWindow: {
+        readonly kind: "updated_recently";
+        readonly days: 3;
+    };
+    readonly space: {
+        readonly archiveMode: "exclude";
+    };
+    readonly task: {
+        readonly statuses: readonly ["backlog", "todo", "in_progress", "in_review", "blocked"];
+    };
+    readonly presentation: {
+        readonly mode: "space_tree";
+        readonly groupBy: "space";
+    };
+};
+export declare function resolveWorkViewCreateConfig(config: unknown): unknown;
+export default class WorkViewsCreate extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        scope: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        config: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'from-json': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/work-views/create.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_WORK_VIEW_CONFIG = void 0;
+exports.resolveWorkViewCreateConfig = resolveWorkViewCreateConfig;
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+const prompt_1 = require("../../lib/prompt");
+exports.DEFAULT_WORK_VIEW_CONFIG = {
+    schemaVersion: 1,
+    timeWindow: { kind: 'updated_recently', days: 3 },
+    space: { archiveMode: 'exclude' },
+    task: {
+        statuses: ['backlog', 'todo', 'in_progress', 'in_review', 'blocked'],
+    },
+    presentation: { mode: 'space_tree', groupBy: 'space' },
+};
+function resolveWorkViewCreateConfig(config) {
+    if (config !== undefined)
+        return config;
+    // The CLI must not hand a shared object to callers that could mutate it
+    // before serialization. This is intentionally the same contract as the
+    // server's Recent active work preset, but the explicit copy keeps the CLI
+    // usable when the API correctly requires a full config at create time.
+    return JSON.parse(JSON.stringify(exports.DEFAULT_WORK_VIEW_CONFIG));
+}
+class WorkViewsCreate extends base_command_1.BaseCommand {
+    static description = 'Create a saved Work View with task, space, time, and presentation config';
+    static examples = [
+        '<%= config.bin %> work-views create --name "My recent work" --json',
+        '<%= config.bin %> work-views create --name "Due this week" --config \'{"schemaVersion":1,"timeWindow":{"kind":"due_within","days":7},"presentation":{"mode":"task_timeline","groupBy":"date"}}\' --json',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        name: core_1.Flags.string({ description: 'View name' }),
+        scope: core_1.Flags.string({
+            options: ['personal', 'workspace'],
+            description: 'Visibility scope',
+        }),
+        config: core_1.Flags.string({
+            description: 'Work View config JSON. Omit for the built-in Recent active work configuration',
+        }),
+        'from-json': core_1.Flags.string({ description: 'Full JSON body' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(WorkViewsCreate);
+        let body = {};
+        try {
+            body = await (0, prompt_1.readJsonBody)(flags['from-json']);
+        }
+        catch (error) {
+            this.error(error.message);
+        }
+        let config;
+        try {
+            config = flags.config ? JSON.parse(flags.config) : undefined;
+        }
+        catch {
+            this.error('--config must be valid JSON.');
+        }
+        const payload = (0, prompt_1.mergeDefined)(body, {
+            name: flags.name,
+            scope: flags.scope,
+            config,
+        });
+        if (!payload.name)
+            this.error('Pass --name, or include it in --from-json.', {
+                exit: 1,
+            });
+        payload.config = resolveWorkViewCreateConfig(payload.config);
+        let result;
+        try {
+            result = await data_provider_1.dataService.createWorkView(payload);
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        this.log(flags.json
+            ? JSON.stringify(result, null, 2)
+            : `Created Work View ${result?.id ?? '?'}.`);
+    }
+}
+exports.default = WorkViewsCreate;

package/dist/commands/work-views/delete.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../base-command';
+export default class WorkViewsDelete extends BaseCommand {
+    static description: string;
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        version: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        yes: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/work-views/delete.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+const prompt_1 = require("../../lib/prompt");
+class WorkViewsDelete extends base_command_1.BaseCommand {
+    static description = 'Delete a Work View';
+    static args = {
+        id: core_1.Args.string({
+            description: 'Work View ID',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        version: core_1.Flags.integer({
+            description: 'Current view version from list/result',
+            required: true,
+        }),
+        yes: core_1.Flags.boolean({ description: 'Skip confirmation' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(WorkViewsDelete);
+        if (!(await (0, prompt_1.confirmDestructive)(`Delete Work View ${args.id}?`, flags.yes)))
+            return void this.log('Cancelled.');
+        let result;
+        try {
+            result = await data_provider_1.dataService.deleteWorkView(args.id, flags.version);
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        this.log(flags.json ? JSON.stringify(result, null, 2) : `Deleted Work View ${args.id}.`);
+    }
+}
+exports.default = WorkViewsDelete;

package/dist/commands/work-views/list.d.ts

@@ -0,0 +1,8 @@
+import { BaseCommand } from '../../base-command';
+export default class WorkViewsList extends BaseCommand {
+    static description: string;
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/work-views/list.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+class WorkViewsList extends base_command_1.BaseCommand {
+    static description = 'List saved Work Views';
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(WorkViewsList);
+        let result;
+        try {
+            result = await data_provider_1.dataService.listWorkViews();
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return void this.log(JSON.stringify(result, null, 2));
+        if (result.defaultCreated)
+            this.log('Created default Work View: Recent active work.');
+        for (const view of result.data)
+            this.log(`${view.id}\t${view.scope}\t${view.name}\tv${view.version}`);
+    }
+}
+exports.default = WorkViewsList;

package/dist/commands/work-views/result.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../base-command';
+export default class WorkViewsResult extends BaseCommand {
+    static description: string;
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/work-views/result.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+class WorkViewsResult extends base_command_1.BaseCommand {
+    static description = 'Read the ACL-safe Space and Task projection for a Work View';
+    static args = {
+        id: core_1.Args.string({
+            description: 'Work View ID',
+            required: true,
+            ignoreStdin: true,
+        }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(WorkViewsResult);
+        let result;
+        try {
+            result = await data_provider_1.dataService.getWorkViewResult(args.id);
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return void this.log(JSON.stringify(result, null, 2));
+        for (const space of result.spaces) {
+            this.log(`${space.title} (${space.activeTaskCount})`);
+            for (const task of space.tasks)
+                this.log(`  ${task.status}\t${task.title}`);
+        }
+    }
+}
+exports.default = WorkViewsResult;

package/dist/commands/work-views/update.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../../base-command';
+export default class WorkViewsUpdate extends BaseCommand {
+    static description: string;
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        version: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        config: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'from-json': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}