@mx-space/cli 0.15.0 → 0.15.1

package/dist/src/services/Renderer/errors.js

@@ -0,0 +1,59 @@
+import { codeForTag, defaultMessageFor, toErrorEnvelope, } from '../../domain/errors';
+import { color, writeStderr, writeStdout } from './primitives';
+const formatIssue = (issue) => {
+    if (!issue || typeof issue !== 'object')
+        return String(issue);
+    const obj = issue;
+    const path = Array.isArray(obj.path) ? obj.path.join('.') : '';
+    const message = typeof obj.message === 'string' ? obj.message : JSON.stringify(obj);
+    const line = typeof obj.line === 'number' ? ` (line ${obj.line})` : '';
+    const suggestions = Array.isArray(obj.suggestions)
+        ? ` — did you mean ${obj.suggestions.join(', ')}?`
+        : '';
+    return `${path ? `${path}: ` : ''}${message}${line}${suggestions}`;
+};
+const formatDetails = (details) => {
+    if (!details || typeof details !== 'object')
+        return [String(details)];
+    if (Array.isArray(details)) {
+        return details.map((item) => formatIssue(item));
+    }
+    if ('issues' in details &&
+        Array.isArray(details.issues)) {
+        return details.issues.map((issue) => formatIssue(issue));
+    }
+    return [JSON.stringify(details)];
+};
+export const emitErrorSync = (err, opts) => {
+    const tag = err._tag;
+    if (opts.json) {
+        if (tag === 'WriteRequiresExplicit') {
+            // Preserve legacy special-case JSON shape for the production write
+            // gate (`error`, `profile`, `api_url`, `hint`).
+            const e = err;
+            writeStdout(`${JSON.stringify({
+                ok: false,
+                error: codeForTag(tag),
+                profile: e.profile ?? null,
+                api_url: e.apiUrl ?? null,
+                hint: e.hint ?? null,
+            })}\n`);
+            return;
+        }
+        writeStdout(`${JSON.stringify(toErrorEnvelope(err))}\n`);
+        return;
+    }
+    const message = 'message' in err && typeof err.message === 'string' && err.message
+        ? err.message
+        : defaultMessageFor(tag);
+    writeStderr(`${color(process.stderr, 31, '✘')} ${message}\n`);
+    if ('details' in err && err.details !== undefined) {
+        const detailLines = formatDetails(err.details);
+        for (const line of detailLines) {
+            writeStderr(`  · ${line}\n`);
+        }
+    }
+    if ('hint' in err && typeof err.hint === 'string' && err.hint.length > 0) {
+        writeStderr(`\nhint: ${err.hint}\n`);
+    }
+};

package/dist/src/services/Renderer/index.d.ts

@@ -0,0 +1,13 @@
+import { Context, Effect, Layer } from 'effect';
+import { type RendererService } from './service';
+export { type DateTimeStyle, formatAbsoluteDateTime, formatDateTime, type FormatDateTimeOptions, formatRelativeTime, looksLikeTimestamp, toDate, tryFormatTimestamp, } from './datetime';
+export { renderReadableGeneric } from './lists';
+export { currentOutputOptions, defaultOutputOptions, type OutputMode, type OutputOptions, } from './options';
+export type { RendererService } from './service';
+export type { View, ViewCtx } from './view';
+declare const Renderer_base: Context.TagClass<Renderer, "Renderer", RendererService>;
+export declare class Renderer extends Renderer_base {
+    static Default: Layer.Layer<Renderer>;
+    /** Apply the given `OutputOptions` for the duration of `effect`. */
+    static withOptions: <A, E, R>(options: import('./options').OutputOptions) => (effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+}

package/dist/src/services/Renderer/index.js

@@ -0,0 +1,11 @@
+import { Context, Effect, Layer } from 'effect';
+import { currentOutputOptions } from './options';
+import { makeService } from './service';
+export { formatAbsoluteDateTime, formatDateTime, formatRelativeTime, looksLikeTimestamp, toDate, tryFormatTimestamp, } from './datetime';
+export { renderReadableGeneric } from './lists';
+export { currentOutputOptions, defaultOutputOptions, } from './options';
+export class Renderer extends Context.Tag('Renderer')() {
+    static Default = Layer.succeed(Renderer, makeService());
+    /** Apply the given `OutputOptions` for the duration of `effect`. */
+    static withOptions = (options) => (effect) => Effect.locally(effect, currentOutputOptions, options);
+}

package/dist/src/services/Renderer/lists.d.ts

@@ -0,0 +1 @@
+export declare const renderReadableGeneric: (data: unknown) => string;

package/dist/src/services/Renderer/lists.js

@@ -0,0 +1,101 @@
+import { formatScalar } from './content';
+import { tryFormatTimestamp } from './datetime';
+// Generic readable renderer for arbitrary payloads. Drives the default
+// `--output readable` rendering for commands that emit ad-hoc objects via
+// `emitSuccess` (mutation responses for auth/profile/config/update/category/
+// topic/...). Keep the shape close to YAML so the output remains pasteable
+// into prose.
+const isPlainObject = (value) => Boolean(value) &&
+    typeof value === 'object' &&
+    !Array.isArray(value) &&
+    !(value instanceof Date);
+// Auto-detect timestamps inside arbitrary payloads and route them through
+// the friendlier formatter so the raw machine form never leaks into the
+// readable output.
+const formatLeaf = (value) => tryFormatTimestamp(value, { style: 'both' }) ?? formatScalar(value);
+const renderReadableLines = (data, indent) => {
+    const pad = '  '.repeat(indent);
+    if (data === null || data === undefined)
+        return [];
+    if (data instanceof Date) {
+        return [`${pad}${formatLeaf(data)}`];
+    }
+    if (typeof data === 'string') {
+        if (data.length === 0)
+            return [];
+        const ts = tryFormatTimestamp(data, { style: 'both' });
+        if (ts !== null)
+            return [`${pad}${ts}`];
+        return data.split('\n').map((line) => `${pad}${line}`);
+    }
+    if (typeof data === 'number' || typeof data === 'boolean') {
+        return [`${pad}${String(data)}`];
+    }
+    if (Array.isArray(data)) {
+        const lines = [];
+        for (const item of data) {
+            if (isPlainObject(item)) {
+                const inner = renderReadableLines(item, indent + 1);
+                if (inner.length === 0)
+                    continue;
+                // Replace the first line's leading pad with "- " marker.
+                const first = inner[0];
+                const stripped = first.startsWith(pad + '  ')
+                    ? first.slice((pad + '  ').length)
+                    : first.trimStart();
+                lines.push(`${pad}- ${stripped}`);
+                for (let i = 1; i < inner.length; i++)
+                    lines.push(inner[i]);
+            }
+            else if (Array.isArray(item)) {
+                const inner = renderReadableLines(item, indent + 1);
+                if (inner.length === 0)
+                    continue;
+                lines.push(`${pad}-`);
+                lines.push(...inner);
+            }
+            else if (item !== null && item !== undefined) {
+                lines.push(`${pad}- ${formatLeaf(item)}`);
+            }
+        }
+        return lines;
+    }
+    if (isPlainObject(data)) {
+        const lines = [];
+        for (const [key, value] of Object.entries(data)) {
+            if (value === null || value === undefined || value === '')
+                continue;
+            if (Array.isArray(value)) {
+                if (value.length === 0)
+                    continue;
+                const allScalar = value.every((v) => v === null ||
+                    v === undefined ||
+                    v instanceof Date ||
+                    typeof v !== 'object');
+                if (allScalar) {
+                    const parts = value
+                        .filter((v) => v !== null && v !== undefined)
+                        .map((v) => formatLeaf(v));
+                    lines.push(`${pad}${key}: ${parts.join(', ')}`);
+                }
+                else {
+                    lines.push(`${pad}${key}:`);
+                    lines.push(...renderReadableLines(value, indent + 1));
+                }
+            }
+            else if (isPlainObject(value)) {
+                const inner = renderReadableLines(value, indent + 1);
+                if (inner.length === 0)
+                    continue;
+                lines.push(`${pad}${key}:`);
+                lines.push(...inner);
+            }
+            else {
+                lines.push(`${pad}${key}: ${formatLeaf(value)}`);
+            }
+        }
+        return lines;
+    }
+    return [`${pad}${String(data)}`];
+};
+export const renderReadableGeneric = (data) => renderReadableLines(data, 0).join('\n');

package/dist/src/services/Renderer/options.d.ts

@@ -0,0 +1,10 @@
+import { FiberRef } from 'effect';
+export type OutputMode = 'pretty-json' | 'json' | 'readable' | 'llm' | 'xml';
+export interface OutputOptions {
+    readonly json: boolean;
+    readonly output: OutputMode;
+    readonly quiet: boolean;
+    readonly verbose: boolean;
+}
+export declare const defaultOutputOptions: OutputOptions;
+export declare const currentOutputOptions: FiberRef.FiberRef<OutputOptions>;

package/dist/src/services/Renderer/options.js

@@ -0,0 +1,13 @@
+import { FiberRef } from 'effect';
+export const defaultOutputOptions = {
+    json: false,
+    output: 'readable',
+    quiet: false,
+    verbose: false,
+};
+// One FiberRef carries the per-run output options. The bin entry sets it once
+// at the root after parsing global flags; tests override it per-Effect via
+// `Effect.locally(currentOutputOptions, ...)`. Choosing a FiberRef over a
+// command-level context parameter keeps every `Api`/`Renderer`/command body
+// free of an explicit options argument while still being fully testable.
+export const currentOutputOptions = FiberRef.unsafeMake(defaultOutputOptions);

package/dist/src/services/Renderer/primitives.d.ts

@@ -0,0 +1,4 @@
+export declare const isTTY: (stream: NodeJS.WriteStream) => boolean;
+export declare const color: (stream: NodeJS.WriteStream, code: number, text: string) => string;
+export declare const writeStdout: (s: string) => void;
+export declare const writeStderr: (s: string) => void;

package/dist/src/services/Renderer/primitives.js

@@ -0,0 +1,12 @@
+export const isTTY = (stream) => Boolean(stream.isTTY);
+export const color = (stream, code, text) => {
+    if (!isTTY(stream))
+        return text;
+    return `\x1B[${code}m${text}\x1B[0m`;
+};
+export const writeStdout = (s) => {
+    process.stdout.write(s);
+};
+export const writeStderr = (s) => {
+    process.stderr.write(s);
+};

package/dist/src/services/Renderer/service.d.ts

@@ -0,0 +1,35 @@
+import { Effect } from 'effect';
+import type { CliError } from '../../domain/errors';
+import { type OutputOptions } from './options';
+import type { View } from './view';
+export interface RendererService {
+    /** Active output configuration in the current fiber. */
+    readonly options: Effect.Effect<OutputOptions>;
+    /** Typed view dispatch — primary path. */
+    readonly emit: <T>(view: View<T>, data: T) => Effect.Effect<void>;
+    /** Generic success payload for ad-hoc data (mutation responses, etc.). */
+    readonly emitSuccess: (data: unknown) => Effect.Effect<void>;
+    /** Info line on stderr (suppressed by `--quiet` / `--json`). */
+    readonly emitInfo: (message: string) => Effect.Effect<void>;
+    /** Warning line on stderr (suppressed by `--json`). */
+    readonly emitWarn: (message: string) => Effect.Effect<void>;
+    /** Error envelope or pretty error to stderr/stdout per output mode. */
+    readonly emitError: (err: CliError) => Effect.Effect<void>;
+    /**
+     * Emit a bespoke ANSI/text view (ad-hoc, no schema — banners). In `--json`
+     * mode the function is never called — `data` is wrapped as a JSON envelope.
+     */
+    readonly emitView: (data: unknown, view: (ctx: {
+        readonly color: boolean;
+    }) => string) => Effect.Effect<void>;
+    /** Convenience for `emitView` whose body is a markdown source string. */
+    readonly emitMarkdown: (data: unknown, markdown: () => string) => Effect.Effect<void>;
+    /**
+     * Multi-line info block on stderr. Honours `--quiet` / `--json` like
+     * `emitInfo`; useful for boxed banners (device-code, etc.).
+     */
+    readonly emitInfoBlock: (block: (ctx: {
+        readonly color: boolean;
+    }) => string) => Effect.Effect<void>;
+}
+export declare const makeService: () => RendererService;

package/dist/src/services/Renderer/service.js

@@ -0,0 +1,123 @@
+import { Effect, FiberRef } from 'effect';
+import { isColorEnabled, renderMarkdownToAnsi } from '../../cli/render';
+import { emitErrorSync } from './errors';
+import { renderReadableGeneric } from './lists';
+import { currentOutputOptions, } from './options';
+import { color, writeStderr, writeStdout } from './primitives';
+export const makeService = () => {
+    const getOpts = FiberRef.get(currentOutputOptions);
+    const emitSuccessSync = (data, opts) => {
+        if (opts.json || opts.output === 'json') {
+            writeStdout(`${JSON.stringify({ ok: true, data })}\n`);
+            return;
+        }
+        if (data === null || data === undefined)
+            return;
+        if (typeof data === 'string') {
+            writeStdout(`${data}\n`);
+            return;
+        }
+        if (opts.output === 'readable') {
+            const rendered = renderReadableGeneric(data);
+            if (rendered)
+                writeStdout(`${rendered}\n`);
+            return;
+        }
+        writeStdout(`${JSON.stringify(data, null, 2)}\n`);
+    };
+    return {
+        options: getOpts,
+        emit: (view, data) => Effect.flatMap(getOpts, (opts) => Effect.sync(() => {
+            // JSON family bypasses the view entirely — kind-agnostic envelope.
+            if (opts.json || opts.output === 'json') {
+                writeStdout(`${JSON.stringify({ ok: true, data })}\n`);
+                return;
+            }
+            if (opts.output === 'pretty-json') {
+                writeStdout(`${JSON.stringify(data, null, 2)}\n`);
+                return;
+            }
+            const mode = opts.output;
+            if (!view.modes.has(mode)) {
+                writeStderr(`${color(process.stderr, 31, '✘')} unsupported --output value for ${view.kind}: ${mode}\n`);
+                return;
+            }
+            let text;
+            if (mode === 'xml' && view.xml) {
+                text = view.xml(data);
+            }
+            else if (mode === 'llm' && view.llm) {
+                text = view.llm(data);
+            }
+            else if (mode === 'llm') {
+                // Fallback: render readable with color disabled — strips all ANSI.
+                const ctx = { color: false, verbose: opts.verbose };
+                text = view.readable(data, ctx);
+            }
+            else {
+                const ctx = {
+                    color: isColorEnabled(process.stdout),
+                    verbose: opts.verbose,
+                };
+                text = view.readable(data, ctx);
+            }
+            writeStdout(`${text}\n`);
+        })),
+        emitSuccess: (data) => Effect.flatMap(getOpts, (opts) => Effect.sync(() => emitSuccessSync(data, opts))),
+        emitInfo: (message) => Effect.flatMap(getOpts, (opts) => Effect.sync(() => {
+            if (opts.quiet || opts.json)
+                return;
+            writeStderr(`${message}\n`);
+        })),
+        emitWarn: (message) => Effect.flatMap(getOpts, (opts) => Effect.sync(() => {
+            if (opts.json)
+                return;
+            writeStderr(`${color(process.stderr, 33, 'warn')}: ${message}\n`);
+        })),
+        emitError: (err) => Effect.flatMap(getOpts, (opts) => Effect.sync(() => emitErrorSync(err, opts))),
+        emitView: (data, view) => Effect.flatMap(getOpts, (opts) => Effect.sync(() => {
+            if (opts.json || opts.output === 'json') {
+                writeStdout(`${JSON.stringify({ ok: true, data })}\n`);
+                return;
+            }
+            if (opts.output === 'pretty-json') {
+                if (data !== null && data !== undefined) {
+                    writeStdout(`${JSON.stringify(data, null, 2)}\n`);
+                }
+                return;
+            }
+            if (data === null || data === undefined)
+                return;
+            const color = isColorEnabled(process.stdout);
+            const text = view({ color });
+            if (text)
+                writeStdout(`${text}\n`);
+        })),
+        emitMarkdown: (data, markdown) => Effect.flatMap(getOpts, (opts) => Effect.sync(() => {
+            if (opts.json || opts.output === 'json') {
+                writeStdout(`${JSON.stringify({ ok: true, data })}\n`);
+                return;
+            }
+            if (opts.output === 'pretty-json') {
+                if (data !== null && data !== undefined) {
+                    writeStdout(`${JSON.stringify(data, null, 2)}\n`);
+                }
+                return;
+            }
+            if (data === null || data === undefined)
+                return;
+            const color = isColorEnabled(process.stdout);
+            const text = renderMarkdownToAnsi(markdown(), { color });
+            if (text)
+                writeStdout(`${text}\n`);
+        })),
+        emitInfoBlock: (block) => Effect.flatMap(getOpts, (opts) => Effect.sync(() => {
+            if (opts.quiet || opts.json)
+                return;
+            const color = isColorEnabled(process.stderr);
+            const text = block({ color });
+            if (text)
+                writeStderr(`${text}\n`);
+        })),
+    };
+};

package/dist/src/services/Renderer/view.d.ts

@@ -0,0 +1,16 @@
+import type { OutputMode } from './options';
+export interface ViewCtx {
+    readonly color: boolean;
+    /** Reserved for per-view verbosity toggles (e.g. `whoami --verbose`). */
+    readonly verbose: boolean;
+}
+export interface View<T> {
+    /** Human-readable kind label used only in error messages. Not a lookup key. */
+    readonly kind: string;
+    /** Modes this view supports. `json` / `pretty-json` are always supported by the service. */
+    readonly modes: ReadonlySet<OutputMode>;
+    readonly readable: (data: T, ctx: ViewCtx) => string;
+    /** Optional. Missing llm falls back to readable with color disabled. */
+    readonly llm?: (data: T) => string;
+    readonly xml?: (data: T) => string;
+}

package/dist/src/services/Renderer/view.js

@@ -0,0 +1 @@
+export {};

package/dist/src/services/Resolver.d.ts

@@ -0,0 +1,47 @@
+import { Context, Effect, Layer } from 'effect';
+import { Generic, ResourceNotFound, ValidationFailed } from '../domain/errors';
+import { Api, type ApiService } from './Api';
+export type ResolverKind = 'category' | 'topic' | 'project';
+export interface ResolvableItem {
+    readonly id: string;
+    readonly slug?: string;
+    readonly name?: string;
+}
+export interface ResolverService {
+    /** Resolve a slug/name/id to an id. Snowflake ids pass through unchanged. */
+    readonly resolveCategory: (value: string) => Effect.Effect<string, ValidationFailed | Generic>;
+    readonly resolveTopic: (value: string) => Effect.Effect<string, ValidationFailed | Generic>;
+    /** Resolve a list of refs (category slugs/ids) to ids. */
+    readonly resolveCategoryRefs: (refs: ReadonlyArray<string>) => Effect.Effect<ReadonlyArray<string>, ValidationFailed | Generic>;
+    /** Resolve a post slug/id to a snowflake id. */
+    readonly resolvePostId: (slugOrId: string) => Effect.Effect<string, ResourceNotFound | ValidationFailed | Generic>;
+    /** Build the read path (`/posts/<category>/<slug>` or `/posts/<id>`). */
+    readonly resolvePostReadPath: (slugOrId: string) => Effect.Effect<string, ResourceNotFound | ValidationFailed | Generic>;
+    /** Resolve a note slug or numeric nid to its snowflake id. */
+    readonly resolveNoteId: (slugOrId: string) => Effect.Effect<string, ResourceNotFound | ValidationFailed | Generic>;
+    /** Resolve a category slug to its snowflake id (via /categories/:slug). */
+    readonly resolveCategoryId: (slugOrId: string) => Effect.Effect<string, ResourceNotFound | ValidationFailed | Generic>;
+    /** Resolve a project name or snowflake id to its id (via /projects/all). */
+    readonly resolveProjectId: (nameOrId: string) => Effect.Effect<string, ResourceNotFound | ValidationFailed | Generic>;
+    /** Bust cache for a given kind, or all if omitted. */
+    readonly invalidate: (kind?: ResolverKind) => Effect.Effect<void>;
+}
+export declare const isSnowflakeId: (value: string) => boolean;
+export declare function matchItem(items: ReadonlyArray<ResolvableItem>, value: string): ResolvableItem | null;
+export declare function levenshtein(a: string, b: string): number;
+export declare function fuzzySuggest(items: ReadonlyArray<ResolvableItem>, value: string, maxDistance?: number): string[];
+export interface ResolverDeps {
+    readonly ttlMs?: number;
+}
+export declare const make: (api: ApiService, deps?: ResolverDeps) => ResolverService;
+declare const Resolver_base: Context.TagClass<Resolver, "Resolver", ResolverService>;
+export declare class Resolver extends Resolver_base {
+    /**
+     * Default layer composes `Resolver` from the ambient `Api` service. Tests can
+     * provide an alternate layer via {@link layer}.
+     */
+    static Default: Layer.Layer<Resolver, never, Api>;
+}
+/** Build a Resolver layer from an explicit `ApiService` (tests). */
+export declare const layer: (api: ApiService, deps?: ResolverDeps) => Layer.Layer<Resolver>;
+export {};