@mx-space/cli 0.15.0 → 0.15.1

package/dist/src/cli/snippet/_resolve.d.ts

@@ -0,0 +1,4 @@
+import { Effect } from 'effect';
+import { ResourceNotFound } from '../../domain/errors';
+import type { ApiService } from '../../services/Api';
+export declare const resolveSnippetId: (api: ApiService, ref: string) => Effect.Effect<string, ResourceNotFound>;

package/dist/src/cli/snippet/_resolve.js

@@ -0,0 +1,32 @@
+import { Effect } from 'effect';
+import { ResourceNotFound } from '../../domain/errors';
+import { isSnowflakeId } from '../../services/Resolver';
+const unwrapList = (res) => {
+    if (Array.isArray(res))
+        return res;
+    if (res && typeof res === 'object') {
+        const data = res.data;
+        if (Array.isArray(data))
+            return data;
+    }
+    return [];
+};
+export const resolveSnippetId = (api, ref) => Effect.gen(function* () {
+    if (isSnowflakeId(ref))
+        return ref;
+    const res = yield* api
+        .request('/snippets/by-path', { query: { path: ref } })
+        .pipe(Effect.catchAll(() => Effect.succeed(null)));
+    const doc = res && typeof res === 'object' ? res.data || res : null;
+    const match = Array.isArray(doc)
+        ? unwrapList(doc).find((s) => s.path === ref)
+        : doc;
+    if (!match?.id) {
+        return yield* Effect.fail(new ResourceNotFound({
+            kind: 'snippet',
+            ref,
+            message: `snippet not found: ${ref}`,
+        }));
+    }
+    return match.id;
+});

package/dist/src/cli/snippet/_sync.d.ts

@@ -0,0 +1,5 @@
+export declare function normalizeRemotePrefix(prefix: string): string;
+export declare function detectSnippetType(remotePath: string, raw: string): "json" | "text" | "skill" | "json5" | "yaml";
+export declare function walkTextFiles(root: string): Promise<string[]>;
+export declare function toRemotePath(prefix: string, localRoot: string, file: string): string;
+export declare function toLocalPath(localRoot: string, prefix: string, remotePath: string): string;

package/dist/src/cli/snippet/_sync.js

@@ -0,0 +1,54 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+const IGNORED_NAMES = new Set([
+    '.git',
+    'node_modules',
+    '__pycache__',
+    '.DS_Store',
+]);
+export function normalizeRemotePrefix(prefix) {
+    const normalized = prefix.replaceAll(/^\/+|\/+$/g, '');
+    return normalized ? `${normalized}/` : '';
+}
+export function detectSnippetType(remotePath, raw) {
+    if (remotePath.endsWith('/SKILL.md') && raw.startsWith('---\n')) {
+        return 'skill';
+    }
+    if (remotePath.endsWith('.json'))
+        return 'json';
+    if (remotePath.endsWith('.json5'))
+        return 'json5';
+    if (remotePath.endsWith('.yaml') || remotePath.endsWith('.yml'))
+        return 'yaml';
+    return 'text';
+}
+export async function walkTextFiles(root) {
+    const files = [];
+    async function visit(current) {
+        const entries = await fs.readdir(current, { withFileTypes: true });
+        for (const entry of entries) {
+            if (IGNORED_NAMES.has(entry.name))
+                continue;
+            const fullPath = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                await visit(fullPath);
+            }
+            else if (entry.isFile()) {
+                files.push(fullPath);
+            }
+        }
+    }
+    await visit(root);
+    return files.sort();
+}
+export function toRemotePath(prefix, localRoot, file) {
+    const relative = path.relative(localRoot, file).split(path.sep).join('/');
+    return `${normalizeRemotePrefix(prefix)}${relative}`;
+}
+export function toLocalPath(localRoot, prefix, remotePath) {
+    const normalizedPrefix = normalizeRemotePrefix(prefix);
+    const relative = normalizedPrefix
+        ? remotePath.slice(normalizedPrefix.length)
+        : remotePath;
+    return path.join(localRoot, ...relative.split('/'));
+}

package/dist/src/cli/snippet/create.d.ts

@@ -0,0 +1,19 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Editor } from '../../services/Editor';
+import { Renderer } from '../../services/Renderer';
+export declare const create: Command.Command<"put", Api | Renderer | Editor, import("../../services/Api").ApiError, {
+    readonly type: import("effect/Option").Option<"function" | "json" | "text" | "skill" | "json5" | "yaml">;
+    readonly file: import("effect/Option").Option<string>;
+    readonly raw: import("effect/Option").Option<string>;
+    readonly comment: import("effect/Option").Option<string>;
+    readonly method: import("effect/Option").Option<"GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "ALL">;
+    readonly metatype: import("effect/Option").Option<string>;
+    readonly schema: import("effect/Option").Option<string>;
+    readonly secret: import("effect/Option").Option<string>;
+    readonly private: boolean;
+    readonly noPrivate: boolean;
+    readonly enable: boolean;
+    readonly noEnable: boolean;
+    readonly path: string;
+}>;

package/dist/src/cli/snippet/create.js

@@ -0,0 +1,35 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { ValidationFailed } from '../../domain/errors';
+import { Api } from '../../services/Api';
+import { Editor } from '../../services/Editor';
+import { Renderer } from '../../services/Renderer';
+import { extForType, resolveRawSource, snippetFieldsOf, snippetWriteOptions, toSnippetFlagInputs, } from './_flags';
+const path = Args.text({ name: 'path' });
+export const create = Command.make('put', { path, ...snippetWriteOptions }, ({ path, ...rest }) => Effect.gen(function* () {
+    const flags = toSnippetFlagInputs(rest);
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    let raw = yield* resolveRawSource(flags, { implicitStdin: true });
+    if (raw === undefined) {
+        if (!process.stdin.isTTY) {
+            return yield* Effect.fail(new ValidationFailed({
+                message: 'no snippet content provided; pass --file, --raw, or pipe stdin',
+            }));
+        }
+        const editor = yield* Editor;
+        raw = yield* editor.openEditor({
+            filename: `snippet.${extForType(flags.type ?? 'json')}`,
+            initialContent: '',
+        });
+    }
+    if (!raw.trim()) {
+        return yield* Effect.fail(new ValidationFailed({ message: 'snippet content is empty' }));
+    }
+    const body = { ...snippetFieldsOf(flags), path, raw };
+    const res = yield* api.request('/snippets/by-path', {
+        method: 'PUT',
+        body,
+    });
+    yield* renderer.emitSuccess(res);
+})).pipe(Command.withDescription('write a snippet by path'));

package/dist/src/cli/snippet/delete.d.ts

@@ -0,0 +1,8 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const del: Command.Command<"rm", Api | Renderer, import("../../services/Api").ApiError, {
+    readonly target: string;
+    readonly force: boolean;
+    readonly recursive: boolean;
+}>;

package/dist/src/cli/snippet/delete.js

@@ -0,0 +1,28 @@
+import { Args, Command, Options } from '@effect/cli';
+import { Effect } from 'effect';
+import { ValidationFailed } from '../../domain/errors';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { isSnowflakeId } from '../../services/Resolver';
+const target = Args.text({ name: 'pathOrId' });
+const force = Options.boolean('force').pipe(Options.withDescription('skip the non-TTY guard'));
+const recursive = Options.boolean('recursive');
+export const del = Command.make('rm', { target, force, recursive }, ({ target, force, recursive }) => Effect.gen(function* () {
+    if (!force && !process.stdin.isTTY) {
+        return yield* Effect.fail(new ValidationFailed({
+            message: 'refusing to delete without --force in non-TTY context',
+        }));
+    }
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    if (isSnowflakeId(target)) {
+        yield* api.request(`/snippets/${target}`, { method: 'DELETE' });
+    }
+    else {
+        yield* api.request('/snippets/by-path', {
+            method: 'DELETE',
+            query: { path: target, recursive },
+        });
+    }
+    yield* renderer.emitSuccess({ deleted: target });
+})).pipe(Command.withDescription('delete a snippet path'));

package/dist/src/cli/snippet/edit.d.ts

@@ -0,0 +1,7 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Editor } from '../../services/Editor';
+import { Renderer } from '../../services/Renderer';
+export declare const edit: Command.Command<"edit", Api | Renderer | Editor, import("../../services/Api").ApiError, {
+    readonly target: string;
+}>;

package/dist/src/cli/snippet/edit.js

@@ -0,0 +1,29 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Api } from '../../services/Api';
+import { Editor } from '../../services/Editor';
+import { Renderer } from '../../services/Renderer';
+import { isSnowflakeId } from '../../services/Resolver';
+import { extForType, pickSnippetFields, unwrapDoc } from './_flags';
+const target = Args.text({ name: 'pathOrId' });
+export const edit = Command.make('edit', { target }, ({ target }) => Effect.gen(function* () {
+    const api = yield* Api;
+    const editor = yield* Editor;
+    const renderer = yield* Renderer;
+    const current = unwrapDoc(yield* api.request(isSnowflakeId(target) ? `/snippets/${target}` : '/snippets/by-path', isSnowflakeId(target) ? undefined : { query: { path: target } }));
+    const initial = typeof current.raw === 'string' ? current.raw : '';
+    const next = yield* editor.openEditor({
+        filename: `snippet.${extForType(current.type)}`,
+        initialContent: initial,
+    });
+    if (next.trim() === initial.trim()) {
+        yield* renderer.emitInfo('no changes');
+        return;
+    }
+    const body = { ...pickSnippetFields(current), raw: next };
+    const res = yield* api.request(isSnowflakeId(target) ? `/snippets/${target}` : '/snippets/by-path', {
+        method: 'PUT',
+        body,
+    });
+    yield* renderer.emitSuccess(res);
+})).pipe(Command.withDescription('edit snippet content via $EDITOR'));

package/dist/src/cli/snippet/get.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const get: Command.Command<"get", Api | Renderer, import("../../services/Api").ApiError, {
+    readonly target: string;
+}>;

package/dist/src/cli/snippet/get.js

@@ -0,0 +1,12 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { isSnowflakeId } from '../../services/Resolver';
+const target = Args.text({ name: 'pathOrId' });
+export const get = Command.make('get', { target }, ({ target }) => Effect.gen(function* () {
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const res = yield* api.request(isSnowflakeId(target) ? `/snippets/${target}` : '/snippets/by-path', isSnowflakeId(target) ? undefined : { query: { path: target } });
+    yield* renderer.emitSuccess(res);
+})).pipe(Command.withDescription('get a snippet by path or id'));

package/dist/src/cli/snippet/index.d.ts

@@ -0,0 +1,43 @@
+import { Command } from '@effect/cli';
+export declare const snippetCmd: Command.Command<"snippet", import("../../services/Api").Api | import("../ai/_poll").Renderer | import("../../services/Editor").Editor, import("../../services/Api").ApiError | import("effect/Cause").UnknownException, {
+    readonly subcommand: import("effect/Option").Option<{
+        readonly type: import("effect/Option").Option<"function" | "json" | "text" | "skill" | "json5" | "yaml">;
+        readonly file: import("effect/Option").Option<string>;
+        readonly raw: import("effect/Option").Option<string>;
+        readonly comment: import("effect/Option").Option<string>;
+        readonly method: import("effect/Option").Option<"GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "ALL">;
+        readonly metatype: import("effect/Option").Option<string>;
+        readonly schema: import("effect/Option").Option<string>;
+        readonly secret: import("effect/Option").Option<string>;
+        readonly private: boolean;
+        readonly noPrivate: boolean;
+        readonly enable: boolean;
+        readonly noEnable: boolean;
+        readonly path: string;
+    } | {
+        readonly target: string;
+        readonly force: boolean;
+        readonly recursive: boolean;
+    } | {
+        readonly target: string;
+    } | {
+        readonly target: string;
+    } | {
+        readonly prefix: import("effect/Option").Option<string>;
+        readonly limit: import("effect/Option").Option<number>;
+        readonly recursive: boolean;
+    } | {
+        readonly remotePrefix: string;
+        readonly localDir: string;
+        readonly dryRun: boolean;
+    } | {
+        readonly localDir: string;
+        readonly remotePrefix: string;
+        readonly dryRun: boolean;
+        readonly forceType: import("effect/Option").Option<"function" | "json" | "text" | "skill" | "json5" | "yaml">;
+    } | {
+        readonly from: string;
+        readonly to: string;
+        readonly recursive: boolean;
+    }>;
+}>;

package/dist/src/cli/snippet/index.js

@@ -0,0 +1,58 @@
+import { Command } from '@effect/cli';
+import { registerCommandHelp } from '../help/registry';
+import { create } from './create';
+import { del } from './delete';
+import { edit } from './edit';
+import { get } from './get';
+import { list } from './list';
+import { pull } from './pull';
+import { push } from './push';
+import { update } from './update';
+const help = registerCommandHelp({
+    name: 'snippet',
+    description: 'manage snippets',
+    skillChapter: 'commands-snippet',
+    verbs: [
+        {
+            name: 'ls',
+            args: ['[prefix]', '[--recursive]', '[--limit <n>]'],
+            description: 'list snippet paths',
+        },
+        {
+            name: 'get',
+            args: ['<path|id>'],
+            description: 'show a single snippet (full, includes raw)',
+        },
+        {
+            name: 'put',
+            args: ['<path>', '[--type <t>]', '[--file <path|-> | --raw <text>]'],
+            description: 'write a snippet',
+        },
+        {
+            name: 'mv',
+            args: ['<from>', '<to>', '[--recursive]'],
+            description: 'move a snippet path',
+        },
+        {
+            name: 'push',
+            args: ['<local-dir>', '<remote-prefix>', '[--dry-run]', '[--type <t>]'],
+            description: 'sync local files into snippet VFS',
+        },
+        {
+            name: 'pull',
+            args: ['<remote-prefix>', '<local-dir>', '[--dry-run]'],
+            description: 'sync snippet VFS files into a local directory',
+        },
+        {
+            name: 'edit',
+            args: ['<path|id>'],
+            description: 'edit snippet content via $EDITOR',
+        },
+        {
+            name: 'rm',
+            args: ['<path|id>', '[--recursive]', '[--force]'],
+            description: 'delete a snippet',
+        },
+    ],
+});
+export const snippetCmd = Command.make('snippet').pipe(Command.withDescription(help.description), Command.withSubcommands([list, get, create, update, push, pull, edit, del]));

package/dist/src/cli/snippet/list.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@effect/cli';
+import { Option } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const list: Command.Command<"ls", Api | Renderer, import("../../services/Api").ApiError, {
+    readonly prefix: Option.Option<string>;
+    readonly limit: Option.Option<number>;
+    readonly recursive: boolean;
+}>;

package/dist/src/cli/snippet/list.js

@@ -0,0 +1,20 @@
+import { Args, Command, Options } from '@effect/cli';
+import { Effect, Option } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+const prefix = Args.text({ name: 'prefix' }).pipe(Args.optional);
+const limit = Options.integer('limit').pipe(Options.optional);
+const recursive = Options.boolean('recursive');
+const unwrap = (value) => Option.getOrUndefined(value);
+export const list = Command.make('ls', { prefix, limit, recursive }, ({ prefix, limit, recursive }) => Effect.gen(function* () {
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const res = yield* api.request('/snippets', {
+        query: {
+            prefix: unwrap(prefix),
+            limit: unwrap(limit),
+            recursive,
+        },
+    });
+    yield* renderer.emitSuccess(res);
+})).pipe(Command.withDescription('list snippet VFS paths'));

package/dist/src/cli/snippet/pull.d.ts

@@ -0,0 +1,8 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const pull: Command.Command<"pull", Api | Renderer, import("../../services/Api").ApiError | import("effect/Cause").UnknownException, {
+    readonly remotePrefix: string;
+    readonly localDir: string;
+    readonly dryRun: boolean;
+}>;

package/dist/src/cli/snippet/pull.js

@@ -0,0 +1,33 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { Args, Command, Options } from '@effect/cli';
+import { Effect } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { toLocalPath } from './_sync';
+const remotePrefix = Args.text({ name: 'remotePrefix' });
+const localDir = Args.text({ name: 'localDir' });
+const dryRun = Options.boolean('dry-run');
+export const pull = Command.make('pull', { remotePrefix, localDir, dryRun }, ({ remotePrefix, localDir, dryRun }) => Effect.gen(function* () {
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const list = (yield* api.request('/snippets', {
+        query: { prefix: remotePrefix, recursive: true, limit: 1000 },
+    }));
+    const objects = (list?.data?.objects ?? list?.objects ?? []);
+    const planned = [];
+    for (const object of objects) {
+        const detail = (yield* api.request('/snippets/by-path', {
+            query: { path: object.path },
+        }));
+        const row = detail?.data ?? detail;
+        const raw = typeof row?.raw === 'string' ? row.raw : '';
+        const local = toLocalPath(localDir, remotePrefix, object.path);
+        planned.push({ remote: object.path, local });
+        if (!dryRun) {
+            yield* Effect.tryPromise(() => fs.mkdir(path.dirname(local), { recursive: true }));
+            yield* Effect.tryPromise(() => fs.writeFile(local, raw, 'utf8'));
+        }
+    }
+    yield* renderer.emitSuccess({ dryRun, pulled: planned });
+})).pipe(Command.withDescription('pull a snippet VFS prefix into a local directory'));

package/dist/src/cli/snippet/push.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@effect/cli';
+import { Option } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const push: Command.Command<"push", Api | Renderer, import("../../services/Api").ApiError | import("effect/Cause").UnknownException, {
+    readonly localDir: string;
+    readonly remotePrefix: string;
+    readonly dryRun: boolean;
+    readonly forceType: Option.Option<"function" | "json" | "text" | "skill" | "json5" | "yaml">;
+}>;

package/dist/src/cli/snippet/push.js

@@ -0,0 +1,31 @@
+import fs from 'node:fs/promises';
+import { Args, Command, Options } from '@effect/cli';
+import { Effect, Option } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { SNIPPET_TYPES } from './_flags';
+import { detectSnippetType, toRemotePath, walkTextFiles } from './_sync';
+const localDir = Args.text({ name: 'localDir' });
+const remotePrefix = Args.text({ name: 'remotePrefix' });
+const dryRun = Options.boolean('dry-run');
+const forceType = Options.choice('type', SNIPPET_TYPES).pipe(Options.optional);
+export const push = Command.make('push', { localDir, remotePrefix, dryRun, forceType }, ({ localDir, remotePrefix, dryRun, forceType }) => Effect.gen(function* () {
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const files = yield* Effect.tryPromise(() => walkTextFiles(localDir));
+    const typeOverride = Option.getOrUndefined(forceType);
+    const planned = [];
+    for (const file of files) {
+        const raw = yield* Effect.tryPromise(() => fs.readFile(file, 'utf8'));
+        const remote = toRemotePath(remotePrefix, localDir, file);
+        const type = typeOverride ?? detectSnippetType(remote, raw);
+        planned.push({ local: file, remote, type });
+        if (!dryRun) {
+            yield* api.request('/snippets/by-path', {
+                method: 'PUT',
+                body: { path: remote, raw, type },
+            });
+        }
+    }
+    yield* renderer.emitSuccess({ dryRun, pushed: planned });
+})).pipe(Command.withDescription('push a local directory into snippet VFS'));

package/dist/src/cli/snippet/update.d.ts

@@ -0,0 +1,8 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const update: Command.Command<"mv", Api | Renderer, import("../../services/Api").ApiError, {
+    readonly from: string;
+    readonly to: string;
+    readonly recursive: boolean;
+}>;

package/dist/src/cli/snippet/update.js

@@ -0,0 +1,16 @@
+import { Args, Command, Options } from '@effect/cli';
+import { Effect } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+const from = Args.text({ name: 'from' });
+const to = Args.text({ name: 'to' });
+const recursive = Options.boolean('recursive');
+export const update = Command.make('mv', { from, to, recursive }, ({ from, to, recursive }) => Effect.gen(function* () {
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const res = yield* api.request('/snippets/move', {
+        method: 'POST',
+        body: { from, to, recursive },
+    });
+    yield* renderer.emitSuccess(res);
+})).pipe(Command.withDescription('move or rename a snippet path'));

package/dist/src/cli/topic/create.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@effect/cli';
+import { Option } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const create: Command.Command<"create", Api | Renderer, import("../../services/Api").ApiError, {
+    readonly name: string;
+    readonly slug: string;
+    readonly description: Option.Option<string>;
+    readonly icon: Option.Option<string>;
+}>;

package/dist/src/cli/topic/create.js

@@ -0,0 +1,24 @@
+import { Command, Options } from '@effect/cli';
+import { Effect, Option } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+const name = Options.text('name');
+const slug = Options.text('slug');
+const description = Options.text('description').pipe(Options.optional);
+const icon = Options.text('icon').pipe(Options.optional);
+export const create = Command.make('create', { name, slug, description, icon }, ({ name, slug, description, icon }) => Effect.gen(function* () {
+    const body = { name, slug };
+    const d = Option.getOrUndefined(description);
+    if (d)
+        body.description = d;
+    const ic = Option.getOrUndefined(icon);
+    if (ic)
+        body.icon = ic;
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const res = yield* api.request('/topics', {
+        method: 'POST',
+        body,
+    });
+    yield* renderer.emitSuccess(res);
+}));

package/dist/src/cli/topic/delete.d.ts

@@ -0,0 +1,7 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const del: Command.Command<"delete", Api | Renderer, import("../../services/Api").ApiError, {
+    readonly slugOrId: string;
+    readonly force: boolean;
+}>;

package/dist/src/cli/topic/delete.js

@@ -0,0 +1,37 @@
+import { Args, Command, Options } from '@effect/cli';
+import { Effect } from 'effect';
+import { ResourceNotFound, ValidationFailed } from '../../domain/errors';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { isSnowflakeId } from '../../services/Resolver';
+const slugOrId = Args.text({ name: 'slugOrId' });
+const force = Options.boolean('force');
+const resolveTopicId = (api, ref) => Effect.gen(function* () {
+    if (isSnowflakeId(ref))
+        return ref;
+    const res = yield* api
+        .request(`/topics/slug/${encodeURIComponent(ref)}`)
+        .pipe(Effect.catchAll(() => Effect.succeed(null)));
+    const id = (res && res.id) ??
+        (res && res.data?.id);
+    if (!id) {
+        return yield* Effect.fail(new ResourceNotFound({
+            kind: 'topic',
+            ref,
+            message: `topic not found: ${ref}`,
+        }));
+    }
+    return id;
+});
+export const del = Command.make('delete', { slugOrId, force }, ({ slugOrId, force }) => Effect.gen(function* () {
+    if (!force && !process.stdin.isTTY) {
+        return yield* Effect.fail(new ValidationFailed({
+            message: 'refusing to delete without --force in non-TTY context',
+        }));
+    }
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const id = yield* resolveTopicId(api, slugOrId);
+    yield* api.request(`/topics/${id}`, { method: 'DELETE' });
+    yield* renderer.emitSuccess({ deleted: id });
+}));

package/dist/src/cli/topic/get.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+export declare const get: Command.Command<"get", Api | Renderer, import("../../services/Api").ApiError, {
+    readonly slugOrId: string;
+}>;

package/dist/src/cli/topic/get.js

@@ -0,0 +1,15 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { isSnowflakeId } from '../../services/Resolver';
+const slugOrId = Args.text({ name: 'slugOrId' });
+export const get = Command.make('get', { slugOrId }, ({ slugOrId }) => Effect.gen(function* () {
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const path = isSnowflakeId(slugOrId)
+        ? `/topics/${slugOrId}`
+        : `/topics/slug/${encodeURIComponent(slugOrId)}`;
+    const res = yield* api.request(path);
+    yield* renderer.emitSuccess(res);
+}));

package/dist/src/cli/topic/index.d.ts

@@ -0,0 +1,20 @@
+import { Command } from '@effect/cli';
+export declare const topicCmd: Command.Command<"topic", import("../../services/Api").Api | import("../ai/_poll").Renderer, import("../../services/Api").ApiError, {
+    readonly subcommand: import("effect/Option").Option<{
+        readonly name: string;
+        readonly slug: string;
+        readonly description: import("effect/Option").Option<string>;
+        readonly icon: import("effect/Option").Option<string>;
+    } | {
+        readonly slugOrId: string;
+        readonly force: boolean;
+    } | {
+        readonly slugOrId: string;
+    } | {} | {
+        readonly slugOrId: string;
+        readonly name: import("effect/Option").Option<string>;
+        readonly slug: import("effect/Option").Option<string>;
+        readonly description: import("effect/Option").Option<string>;
+        readonly icon: import("effect/Option").Option<string>;
+    }>;
+}>;