@mx-space/cli 0.15.0 → 0.15.1

package/dist/src/cli/render/markdown.js

@@ -0,0 +1,196 @@
+import { eastAsianWidth } from 'get-east-asian-width';
+import { highlightCode } from './codehighlight';
+export const ANSI = {
+    reset: '\x1B[0m',
+    bold: '\x1B[1m',
+    dim: '\x1B[2m',
+    red: '\x1B[31m',
+    green: '\x1B[32m',
+    yellow: '\x1B[33m',
+    blue: '\x1B[34m',
+    magenta: '\x1B[35m',
+    cyan: '\x1B[36m',
+};
+export const wrap = (code, text, on) => on ? `${code}${text}${ANSI.reset}` : text;
+export const visibleLen = (s) => {
+    // eslint-disable-next-line no-control-regex
+    const text = s.replaceAll(/\x1B\[[\d;]*m/g, '');
+    let width = 0;
+    for (const ch of text) {
+        const cp = ch.codePointAt(0);
+        if (cp !== undefined)
+            width += eastAsianWidth(cp);
+    }
+    return width;
+};
+export const isColorEnabled = (stream) => {
+    if (process.env.NO_COLOR && process.env.NO_COLOR !== '')
+        return false;
+    if (process.env.FORCE_COLOR && process.env.FORCE_COLOR !== '0')
+        return true;
+    return Boolean(stream.isTTY);
+};
+/**
+ * Parse inline spans inside a single line of paragraph text.
+ *
+ * Order matters: we strip inline code spans first (so their contents are
+ * never re-interpreted as bold), then bold.
+ */
+const renderInline = (line, opts) => {
+    // Inline code: `text`
+    let out = line.replaceAll(/`([^`]+)`/g, (_m, inner) => wrap(ANSI.cyan, inner, opts.color));
+    // Bold: **text**
+    out = out.replaceAll(/\*\*([^*]+)\*\*/g, (_m, inner) => wrap(ANSI.bold, inner, opts.color));
+    return out;
+};
+const parseTable = (source, start) => {
+    // Header row must start with `|` and the next row must be the alignment row
+    // matching the same pipe layout.
+    if (start + 1 >= source.length)
+        return null;
+    const header = source[start];
+    const sep = source[start + 1];
+    if (!header.startsWith('|') || !sep.startsWith('|'))
+        return null;
+    // eslint-disable-next-line regexp/no-super-linear-backtracking, unicorn/better-regex -- separator-row regex; safe in practice (literal `|` anchors each cell)
+    if (!/^(?:\|[ \t]*:?-+:?[ \t]*)+\|?[ \t]*$/.test(sep))
+        return null;
+    const splitRow = (row) => {
+        const cells = row.split('|').map((c) => c.trim());
+        // Strip leading/trailing empties created by the surrounding pipes.
+        if (cells.length > 0 && cells[0] === '')
+            cells.shift();
+        if (cells.length > 0 && cells.at(-1) === '')
+            cells.pop();
+        return cells;
+    };
+    const rows = [{ cells: splitRow(header) }];
+    let i = start + 2;
+    while (i < source.length) {
+        const row = source[i];
+        if (!row.startsWith('|'))
+            break;
+        rows.push({ cells: splitRow(row) });
+        i++;
+    }
+    return { rows, end: i };
+};
+const renderTable = (rows, opts) => {
+    if (rows.length === 0)
+        return '';
+    // Render each cell through inline span parsing first so we can measure
+    // visible width (post inline-styling, the ANSI sequences add no visible
+    // width).
+    const rendered = rows.map((r) => r.cells.map((c) => renderInline(c, opts)));
+    const numCols = Math.max(...rendered.map((r) => r.length));
+    const widths = [];
+    for (let c = 0; c < numCols; c++) {
+        let max = 0;
+        for (const row of rendered) {
+            const cell = row[c] ?? '';
+            if (visibleLen(cell) > max)
+                max = visibleLen(cell);
+        }
+        widths.push(max);
+    }
+    const padRight = (s, width) => {
+        const visible = visibleLen(s);
+        return visible < width ? s + ' '.repeat(width - visible) : s;
+    };
+    const lines = [];
+    rendered.forEach((row, rowIdx) => {
+        const cells = row.map((cell, idx) => padRight(cell, widths[idx]));
+        if (rowIdx === 0) {
+            // Header: bold the cells (text already styled via renderInline; wrap
+            // the whole row in bold for emphasis).
+            lines.push('  ' + cells.map((c) => wrap(ANSI.bold, c, opts.color)).join('  '));
+            // Underline rule.
+            lines.push('  ' +
+                widths
+                    .map((w) => wrap(ANSI.dim, '-'.repeat(w), opts.color))
+                    .join('  '));
+        }
+        else {
+            lines.push('  ' + cells.join('  '));
+        }
+    });
+    return lines.join('\n');
+};
+const renderHeading = (level, text, opts) => {
+    const styled = renderInline(text, opts);
+    if (level === 1) {
+        return wrap(`${ANSI.bold}${ANSI.magenta}`, styled, opts.color);
+    }
+    if (level === 2) {
+        return wrap(`${ANSI.bold}${ANSI.yellow}`, styled.toUpperCase(), opts.color);
+    }
+    return wrap(ANSI.bold, styled, opts.color);
+};
+export const renderMarkdownToAnsi = (markdown, opts) => {
+    const source = markdown.split('\n');
+    const out = [];
+    let i = 0;
+    while (i < source.length) {
+        const line = source[i];
+        // Fenced code block.
+        if (line.startsWith('```')) {
+            const lang = line.slice(3).trim();
+            i++;
+            const code = [];
+            while (i < source.length && !source[i].startsWith('```')) {
+                code.push(source[i]);
+                i++;
+            }
+            if (i < source.length)
+                i++; // skip closing fence
+            const highlighted = highlightCode(code.join('\n'), lang, opts.color);
+            for (const c of highlighted.split('\n')) {
+                out.push('  ' + c);
+            }
+            continue;
+        }
+        // Indented code (4 spaces).
+        if (line.startsWith('    ')) {
+            out.push('  ' + wrap(ANSI.cyan, line.slice(4), opts.color));
+            i++;
+            continue;
+        }
+        // Heading.
+        const headingMatch = /^(#{1,6}) (.+)$/.exec(line);
+        if (headingMatch) {
+            const level = headingMatch[1].length;
+            // Blank line before non-leading headings, for breathing room.
+            if (out.length > 0 && out.at(-1) !== '')
+                out.push('');
+            out.push(renderHeading(level, headingMatch[2], opts));
+            i++;
+            continue;
+        }
+        // Table.
+        if (line.startsWith('|')) {
+            const parsed = parseTable(source, i);
+            if (parsed) {
+                out.push(renderTable(parsed.rows, opts));
+                i = parsed.end;
+                continue;
+            }
+        }
+        // List item.
+        if (/^[*-]\s+/.test(line)) {
+            const rest = line.replace(/^[*-]\s+/, '');
+            out.push('  • ' + renderInline(rest, opts));
+            i++;
+            continue;
+        }
+        // Blank line.
+        if (line.trim() === '') {
+            out.push('');
+            i++;
+            continue;
+        }
+        // Plain paragraph.
+        out.push(renderInline(line, opts));
+        i++;
+    }
+    return out.join('\n');
+};

package/dist/src/cli/render/metadata-block.d.ts

@@ -0,0 +1,14 @@
+export interface MetadataBlockInput {
+    readonly title?: string;
+    /** Fallback heading when title is empty (e.g. kind label like 'post'). */
+    readonly kind?: string;
+    readonly fields: ReadonlyArray<readonly [string, unknown]>;
+    /** Optional summary line shown dim below the field block. */
+    readonly summary?: string;
+    /** Body string. Routed through markdown renderer iff bodyFormat = 'markdown'. */
+    readonly body?: string;
+    readonly bodyFormat?: 'markdown' | 'litexml' | 'text';
+}
+export declare const renderMetadataBlock: (input: MetadataBlockInput, ctx: {
+    readonly color: boolean;
+}) => string;

package/dist/src/cli/render/metadata-block.js

@@ -0,0 +1,50 @@
+import { formatScalar } from '../../services/Renderer/content';
+import { tryFormatTimestamp } from '../../services/Renderer/datetime';
+import { formatStateBadge, SEPARATOR_WIDTH } from './helpers';
+import { renderLexicalAnsi } from './lexical';
+import { ANSI, renderMarkdownToAnsi, visibleLen, wrap } from './markdown';
+const formatFieldValue = (key, value, color) => {
+    if (key === 'state') {
+        return formatStateBadge(value, color) ?? formatScalar(value);
+    }
+    return tryFormatTimestamp(value, { style: 'both' }) ?? formatScalar(value);
+};
+export const renderMetadataBlock = (input, ctx) => {
+    const { color } = ctx;
+    const { title, kind, fields: rawFields, summary, body, bodyFormat } = input;
+    const fields = rawFields.filter(([, value]) => value !== undefined && value !== null && value !== '');
+    const lines = [];
+    if (title) {
+        lines.push(wrap(ANSI.bold, title, color));
+        const ruleLen = Math.min(Math.max(visibleLen(title), 24), SEPARATOR_WIDTH);
+        lines.push(wrap(ANSI.dim, '─'.repeat(ruleLen), color));
+    }
+    else if (kind) {
+        lines.push(kind);
+    }
+    const labelWidth = fields.reduce((max, [key]) => Math.max(max, key.length), 0);
+    for (const [key, value] of fields) {
+        const label = wrap(ANSI.dim, key.padEnd(labelWidth), color);
+        const rendered = formatFieldValue(key, value, color);
+        lines.push(`${label}  ${rendered}`);
+    }
+    if (summary) {
+        lines.push('');
+        lines.push(wrap(ANSI.dim, summary, color));
+    }
+    if (body) {
+        lines.push('');
+        lines.push(wrap(ANSI.dim, '─'.repeat(SEPARATOR_WIDTH), color));
+        lines.push('');
+        if (bodyFormat === 'markdown') {
+            lines.push(renderMarkdownToAnsi(body, { color }));
+        }
+        else if (bodyFormat === 'litexml') {
+            lines.push(renderLexicalAnsi(body, { color }));
+        }
+        else {
+            lines.push(body);
+        }
+    }
+    return lines.join('\n');
+};

package/dist/src/cli/skill/all.d.ts

@@ -0,0 +1,4 @@
+import { Command } from '@effect/cli';
+import { Renderer } from '../../services/Renderer';
+import { Skill } from '../../services/Skill';
+export declare const all: Command.Command<"all", Renderer | Skill, import("../../domain/errors").SkillCorpusEmpty, {}>;

package/dist/src/cli/skill/all.js

@@ -0,0 +1,11 @@
+import { Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Renderer } from '../../services/Renderer';
+import { Skill } from '../../services/Skill';
+import { skillAllView } from './views';
+export const all = Command.make('all', {}, () => Effect.gen(function* () {
+    const skill = yield* Skill;
+    const renderer = yield* Renderer;
+    const chapters = yield* skill.all;
+    yield* renderer.emit(skillAllView, chapters);
+}));

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

@@ -0,0 +1,6 @@
+import { Command } from '@effect/cli';
+import { Renderer } from '../../services/Renderer';
+import { Skill } from '../../services/Skill';
+export declare const get: Command.Command<"get", Renderer | Skill, import("../../domain/errors").ChapterNotFound | import("../../domain/errors").SkillCorpusEmpty, {
+    readonly slug: string;
+}>;

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

@@ -0,0 +1,12 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Renderer } from '../../services/Renderer';
+import { Skill } from '../../services/Skill';
+import { skillChapterView } from './views';
+const slugArg = Args.text({ name: 'slug' });
+export const get = Command.make('get', { slug: slugArg }, ({ slug }) => Effect.gen(function* () {
+    const skill = yield* Skill;
+    const renderer = yield* Renderer;
+    const chapter = yield* skill.get(slug);
+    yield* renderer.emit(skillChapterView, chapter);
+}));

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

@@ -0,0 +1,10 @@
+import { Command } from '@effect/cli';
+import { Renderer } from '../../services/Renderer';
+import { Skill } from '../../services/Skill';
+export declare const skillCmd: Command.Command<"skill", Renderer | Skill, import("../../domain/errors").ChapterNotFound | import("../../domain/errors").SkillCorpusEmpty, {
+    readonly subcommand: import("effect/Option").Option<{} | {
+        readonly slug: string;
+    } | {} | {
+        readonly keyword: string;
+    }>;
+}>;

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

@@ -0,0 +1,34 @@
+import { Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Renderer } from '../../services/Renderer';
+import { Skill } from '../../services/Skill';
+import { registerCommandHelp } from '../help/registry';
+import { all } from './all';
+import { get } from './get';
+import { list } from './list';
+import { search } from './search';
+import { skillListView } from './views';
+const help = registerCommandHelp({
+    name: 'skill',
+    description: 'read bundled AI skill chapters (commands, authoring, liteXML)',
+    verbs: [
+        { name: 'list', description: 'list all chapters (default verb)' },
+        {
+            name: 'get',
+            args: ['<slug>'],
+            description: 'print one chapter as raw markdown',
+        },
+        { name: 'all', description: 'concatenate every chapter in registry order' },
+        {
+            name: 'search',
+            args: ['<keyword>'],
+            description: 'substring search across chapter title, description, body',
+        },
+    ],
+});
+export const skillCmd = Command.make('skill', {}, () => Effect.gen(function* () {
+    const skill = yield* Skill;
+    const renderer = yield* Renderer;
+    const chapters = yield* skill.list;
+    yield* renderer.emit(skillListView, chapters);
+})).pipe(Command.withDescription(help.description), Command.withSubcommands([list, get, all, search]));

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

@@ -0,0 +1,4 @@
+import { Command } from '@effect/cli';
+import { Renderer } from '../../services/Renderer';
+import { Skill } from '../../services/Skill';
+export declare const list: Command.Command<"list", Renderer | Skill, import("../../domain/errors").SkillCorpusEmpty, {}>;

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

@@ -0,0 +1,11 @@
+import { Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Renderer } from '../../services/Renderer';
+import { Skill } from '../../services/Skill';
+import { skillListView } from './views';
+export const list = Command.make('list', {}, () => Effect.gen(function* () {
+    const skill = yield* Skill;
+    const renderer = yield* Renderer;
+    const chapters = yield* skill.list;
+    yield* renderer.emit(skillListView, chapters);
+}));

package/dist/src/cli/skill/search.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@effect/cli';
+import { Renderer } from '../../services/Renderer';
+import { Skill } from '../../services/Skill';
+export declare const search: Command.Command<"search", Renderer | Skill, import("../../domain/errors").SkillCorpusEmpty, {
+    readonly keyword: string;
+}>;

package/dist/src/cli/skill/search.js

@@ -0,0 +1,12 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Renderer } from '../../services/Renderer';
+import { Skill } from '../../services/Skill';
+import { skillSearchView } from './views';
+const keywordArg = Args.text({ name: 'keyword' });
+export const search = Command.make('search', { keyword: keywordArg }, ({ keyword }) => Effect.gen(function* () {
+    const skill = yield* Skill;
+    const renderer = yield* Renderer;
+    const hits = yield* skill.search(keyword);
+    yield* renderer.emit(skillSearchView, hits);
+}));

package/dist/src/cli/skill/views.d.ts

@@ -0,0 +1,6 @@
+import type { View } from '../../services/Renderer/view';
+import type { Chapter, SearchHit } from '../../services/Skill';
+export declare const skillListView: View<readonly Chapter[]>;
+export declare const skillChapterView: View<Chapter>;
+export declare const skillAllView: View<readonly Chapter[]>;
+export declare const skillSearchView: View<readonly SearchHit[]>;

package/dist/src/cli/skill/views.js

@@ -0,0 +1,90 @@
+import { renderMarkdownToAnsi } from '../render';
+import { ANSI, dim, renderTable, wrap } from '../ui';
+const xmlEscape = (s) => s
+    .replaceAll('&', '&')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;');
+export const skillListView = {
+    kind: 'skill-list',
+    modes: new Set(['readable', 'llm', 'xml']),
+    readable: (chapters, { color }) => {
+        if (chapters.length === 0)
+            return dim('no chapters loaded', color);
+        return renderTable([
+            { key: 'slug', label: 'slug' },
+            { key: 'title', label: 'title' },
+            { key: 'description', label: 'description' },
+            { key: 'source', label: 'src' },
+        ], chapters.map((c) => ({
+            slug: wrap(ANSI.bold, c.slug, color),
+            title: c.title,
+            description: c.description,
+            source: c.source === 'haklex' ? dim('haklex', color) : 'cli',
+        })), { color });
+    },
+    llm: (chapters) => chapters.map((c) => `${c.slug}\t${c.description}`).join('\n'),
+    xml: (chapters) => {
+        const inner = chapters
+            .map((c) => `  <chapter slug="${xmlEscape(c.slug)}" title="${xmlEscape(c.title)}" description="${xmlEscape(c.description)}" source="${c.source}" />`)
+            .join('\n');
+        return `<chapters>\n${inner}\n</chapters>`;
+    },
+};
+const renderChapterReadable = (chapter, color) => {
+    const header = `# ${chapter.title}\n\n_${chapter.description}_\n\n`;
+    return renderMarkdownToAnsi(header + chapter.body, { color }).trimEnd();
+};
+export const skillChapterView = {
+    kind: 'skill-chapter',
+    modes: new Set(['readable', 'llm', 'xml']),
+    readable: (chapter, { color }) => renderChapterReadable(chapter, color),
+    llm: (chapter) => chapter.body.trimEnd(),
+    xml: (chapter) => `<chapter slug="${xmlEscape(chapter.slug)}" title="${xmlEscape(chapter.title)}" source="${chapter.source}">\n${chapter.body.trimEnd()}\n</chapter>`,
+};
+export const skillAllView = {
+    kind: 'skill-all',
+    modes: new Set(['readable', 'llm', 'xml']),
+    readable: (chapters, { color }) => chapters.map((c) => renderChapterReadable(c, color)).join('\n\n'),
+    llm: (chapters) => chapters
+        .map((c) => `# ${c.title} (${c.slug})\n\n${c.body.trimEnd()}`)
+        .join('\n\n---\n\n'),
+    xml: (chapters) => {
+        const inner = chapters
+            .map((c) => `<chapter slug="${xmlEscape(c.slug)}" title="${xmlEscape(c.title)}" source="${c.source}">\n${c.body.trimEnd()}\n</chapter>`)
+            .join('\n');
+        return `<chapters>\n${inner}\n</chapters>`;
+    },
+};
+export const skillSearchView = {
+    kind: 'skill-search',
+    modes: new Set(['readable', 'llm', 'xml']),
+    readable: (hits, { color }) => {
+        if (hits.length === 0)
+            return dim('no matches', color);
+        const lines = [];
+        for (const h of hits) {
+            lines.push(`${wrap(ANSI.bold, h.slug, color)} — ${h.title}`);
+            lines.push(`  ${dim(h.description, color)}`);
+            for (const snippet of h.snippets) {
+                lines.push(`  ${snippet}`);
+            }
+            lines.push('');
+        }
+        return lines.join('\n').trimEnd();
+    },
+    llm: (hits) => hits
+        .map((h) => [`# ${h.title} (${h.slug})`, h.description, '', ...h.snippets].join('\n'))
+        .join('\n\n---\n\n'),
+    xml: (hits) => {
+        const inner = hits
+            .map((h) => {
+            const snippets = h.snippets
+                .map((s) => `    <snippet>${xmlEscape(s)}</snippet>`)
+                .join('\n');
+            return `  <hit slug="${xmlEscape(h.slug)}" title="${xmlEscape(h.title)}">\n${snippets}\n  </hit>`;
+        })
+            .join('\n');
+        return `<hits>\n${inner}\n</hits>`;
+    },
+};

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

@@ -0,0 +1,57 @@
+import { Options } from '@effect/cli';
+import { Effect, Option } from 'effect';
+import type { Generic, ValidationFailed } from '../../domain/errors';
+import { Editor } from '../../services/Editor';
+export declare const SNIPPET_TYPES: readonly ["json", "json5", "function", "text", "yaml", "skill"];
+export declare const SNIPPET_KEYS: readonly ["path", "type", "raw", "private", "comment", "metatype", "schema", "method", "secret", "enable"];
+export declare const snippetWriteOptions: {
+    type: Options.Options<Option.Option<"function" | "json" | "text" | "skill" | "json5" | "yaml">>;
+    file: Options.Options<Option.Option<string>>;
+    raw: Options.Options<Option.Option<string>>;
+    comment: Options.Options<Option.Option<string>>;
+    method: Options.Options<Option.Option<"GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "ALL">>;
+    metatype: Options.Options<Option.Option<string>>;
+    schema: Options.Options<Option.Option<string>>;
+    secret: Options.Options<Option.Option<string>>;
+    private: Options.Options<boolean>;
+    noPrivate: Options.Options<boolean>;
+    enable: Options.Options<boolean>;
+    noEnable: Options.Options<boolean>;
+};
+export interface SnippetWriteOptionsParsed {
+    readonly type: Option.Option<string>;
+    readonly file: Option.Option<string>;
+    readonly raw: Option.Option<string>;
+    readonly comment: Option.Option<string>;
+    readonly method: Option.Option<string>;
+    readonly metatype: Option.Option<string>;
+    readonly schema: Option.Option<string>;
+    readonly secret: Option.Option<string>;
+    readonly private: boolean;
+    readonly noPrivate: boolean;
+    readonly enable: boolean;
+    readonly noEnable: boolean;
+}
+export interface SnippetFlagInputs {
+    readonly type?: string;
+    readonly file?: string;
+    readonly raw?: string;
+    readonly comment?: string;
+    readonly method?: string;
+    readonly metatype?: string;
+    readonly schema?: string;
+    readonly secret?: string;
+    readonly private?: boolean;
+    readonly enable?: boolean;
+}
+export declare const toSnippetFlagInputs: (opts: SnippetWriteOptionsParsed) => SnippetFlagInputs;
+export declare const snippetFieldsOf: (flags: SnippetFlagInputs) => Record<string, unknown>;
+export declare const resolveRawSource: (flags: {
+    readonly file?: string;
+    readonly raw?: string;
+}, opts: {
+    readonly implicitStdin: boolean;
+}) => Effect.Effect<string | undefined, ValidationFailed | Generic, Editor>;
+export declare const unwrapDoc: (res: unknown) => Record<string, unknown>;
+export declare const pickSnippetFields: (doc: Record<string, unknown>) => Record<string, unknown>;
+export declare const extForType: (type: unknown) => string;

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

@@ -0,0 +1,123 @@
+import { Options } from '@effect/cli';
+import { Effect, Option } from 'effect';
+import { Editor } from '../../services/Editor';
+const optional = (self) => Options.optional(self);
+const unwrap = (value) => Option.getOrUndefined(value);
+export const SNIPPET_TYPES = [
+    'json',
+    'json5',
+    'function',
+    'text',
+    'yaml',
+    'skill',
+];
+export const SNIPPET_KEYS = [
+    'path',
+    'type',
+    'raw',
+    'private',
+    'comment',
+    'metatype',
+    'schema',
+    'method',
+    'secret',
+    'enable',
+];
+const type = optional(Options.choice('type', SNIPPET_TYPES));
+const file = optional(Options.text('file'));
+const raw = optional(Options.text('raw'));
+const comment = optional(Options.text('comment'));
+const method = optional(Options.choice('method', ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'ALL']));
+const metatype = optional(Options.text('metatype'));
+const schema = optional(Options.text('schema'));
+const secret = optional(Options.text('secret'));
+const privateFlag = Options.boolean('private');
+const noPrivateFlag = Options.boolean('no-private');
+const enableFlag = Options.boolean('enable');
+const noEnableFlag = Options.boolean('no-enable');
+export const snippetWriteOptions = {
+    type,
+    file,
+    raw,
+    comment,
+    method,
+    metatype,
+    schema,
+    secret,
+    private: privateFlag,
+    noPrivate: noPrivateFlag,
+    enable: enableFlag,
+    noEnable: noEnableFlag,
+};
+export const toSnippetFlagInputs = (opts) => ({
+    type: unwrap(opts.type),
+    file: unwrap(opts.file),
+    raw: unwrap(opts.raw),
+    comment: unwrap(opts.comment),
+    method: unwrap(opts.method),
+    metatype: unwrap(opts.metatype),
+    schema: unwrap(opts.schema),
+    secret: unwrap(opts.secret),
+    private: opts.private ? true : opts.noPrivate ? false : undefined,
+    enable: opts.enable ? true : opts.noEnable ? false : undefined,
+});
+export const snippetFieldsOf = (flags) => {
+    const out = {};
+    if (flags.type !== undefined)
+        out.type = flags.type;
+    if (flags.comment !== undefined)
+        out.comment = flags.comment;
+    if (flags.method !== undefined)
+        out.method = flags.method;
+    if (flags.metatype !== undefined)
+        out.metatype = flags.metatype;
+    if (flags.schema !== undefined)
+        out.schema = flags.schema;
+    if (flags.secret !== undefined)
+        out.secret = flags.secret;
+    if (flags.private !== undefined)
+        out.private = flags.private;
+    if (flags.enable !== undefined)
+        out.enable = flags.enable;
+    return out;
+};
+export const resolveRawSource = (flags, opts) => Effect.gen(function* () {
+    if (flags.file !== undefined) {
+        const editor = yield* Editor;
+        return yield* editor.readFileOrStdin(flags.file);
+    }
+    if (flags.raw !== undefined)
+        return flags.raw;
+    if (opts.implicitStdin && !process.stdin.isTTY) {
+        const editor = yield* Editor;
+        const piped = yield* editor.readFileOrStdin(undefined);
+        return piped.trim() ? piped : undefined;
+    }
+    return undefined;
+});
+export const unwrapDoc = (res) => {
+    if (!res || typeof res !== 'object')
+        return {};
+    const r = res;
+    if (r.data && typeof r.data === 'object' && !Array.isArray(r.data)) {
+        return r.data;
+    }
+    return r;
+};
+export const pickSnippetFields = (doc) => {
+    const out = {};
+    for (const key of SNIPPET_KEYS) {
+        if (key in doc && doc[key] !== undefined)
+            out[key] = doc[key];
+    }
+    return out;
+};
+const EXT_BY_TYPE = {
+    json: 'json',
+    json5: 'json5',
+    function: 'js',
+    yaml: 'yaml',
+    text: 'txt',
+    skill: 'md',
+};
+export const extForType = (type) => (typeof type === 'string' && EXT_BY_TYPE[type]) || 'txt';