@mx-space/cli 0.15.1 → 0.15.2

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

@@ -1,59 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

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

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

@@ -1,101 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

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

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

@@ -1,47 +0,0 @@
-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 {};