@mx-space/cli 0.15.0 → 0.15.1

package/dist/src/cli/profile/mark.js

@@ -0,0 +1,23 @@
+import { Args, Command, Options } from '@effect/cli';
+import { Effect, Option } from 'effect';
+import { ValidationFailed } from '../../domain/errors';
+import { Profile } from '../../services/Profile';
+import { Renderer } from '../../services/Renderer';
+const name = Args.text({ name: 'name' });
+const production = Options.boolean('production', {
+    negationNames: ['no-production'],
+}).pipe(Options.optional);
+export const mark = Command.make('mark', { name, production }, ({ name, production }) => Effect.gen(function* () {
+    const profile = yield* Profile;
+    const renderer = yield* Renderer;
+    yield* profile.validateName(name);
+    if (Option.isNone(production)) {
+        return yield* Effect.fail(new ValidationFailed({
+            message: 'one of --production or --no-production is required',
+        }));
+    }
+    const value = production.value;
+    yield* profile.mark(name, { production: value });
+    const flag = value ? '--production' : '--no-production';
+    yield* renderer.emitInfo(`mxs: profile '${name}' marked with ${flag}`);
+}));

package/dist/src/cli/profile/rm.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@effect/cli';
+import { FileSystem } from '@effect/platform';
+import { Option } from 'effect';
+import { ValidationFailed } from '../../domain/errors';
+import { Config } from '../../services/Config';
+import { Editor } from '../../services/Editor';
+import { Profile } from '../../services/Profile';
+import { Renderer } from '../../services/Renderer';
+export declare const rm: Command.Command<"rm", FileSystem.FileSystem | Config | Renderer | Editor | Profile, ValidationFailed | import("../../domain/errors").ResourceNotFound | import("../../domain/errors").ProfileInvalidName | import("../../domain/errors").Generic, {
+    readonly name: string;
+    readonly force: Option.Option<boolean>;
+}>;

package/dist/src/cli/profile/rm.js

@@ -0,0 +1,50 @@
+import { Args, Command, Options } from '@effect/cli';
+import { FileSystem } from '@effect/platform';
+import { Effect, Option } from 'effect';
+import { ValidationFailed } from '../../domain/errors';
+import { Config } from '../../services/Config';
+import { Editor } from '../../services/Editor';
+import { Profile } from '../../services/Profile';
+import { Renderer } from '../../services/Renderer';
+const name = Args.text({ name: 'name' });
+const force = Options.boolean('force').pipe(Options.optional);
+export const rm = Command.make('rm', { name, force }, ({ name, force }) => Effect.gen(function* () {
+    const profile = yield* Profile;
+    const config = yield* Config;
+    const editor = yield* Editor;
+    const renderer = yield* Renderer;
+    yield* profile.validateName(name);
+    const forced = Option.getOrElse(force, () => false);
+    const current = yield* profile.current;
+    if (current === name && !forced) {
+        return yield* Effect.fail(new ValidationFailed({
+            message: `profile '${name}' is currently active; pass --force to remove it`,
+            hint: 'switch to another profile first with `mxs profile use <name>`',
+        }));
+    }
+    if (!forced) {
+        if (!process.stdin.isTTY) {
+            return yield* Effect.fail(new ValidationFailed({
+                message: `cannot remove profile '${name}' non-interactively`,
+                hint: 'pass --force to confirm removal in a non-interactive context',
+            }));
+        }
+        const confirmed = yield* editor
+            .confirm(`Remove profile '${name}'? This cannot be undone.`)
+            .pipe(Effect.catchAll(() => Effect.succeed(false)));
+        if (!confirmed)
+            return;
+    }
+    yield* profile.rm(name);
+    yield* renderer.emitInfo(`mxs: profile '${name}' removed`);
+    if (current === name) {
+        // Clear the stale active-profile pointer so subsequent commands don't
+        // hit profile.not_found on a profile that no longer exists.
+        const fs = yield* FileSystem.FileSystem;
+        const currentPath = yield* config.getCurrentPath;
+        yield* fs
+            .remove(currentPath, { force: true })
+            .pipe(Effect.catchAll(() => Effect.void));
+        yield* renderer.emitInfo('mxs: cleared active profile pointer');
+    }
+}));

package/dist/src/cli/profile/show.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@effect/cli';
+import { Option } from 'effect';
+import { ProfileNoneActive } from '../../domain/errors';
+import { Config } from '../../services/Config';
+import { Profile } from '../../services/Profile';
+import { Renderer } from '../../services/Renderer';
+export declare const show: Command.Command<"show", Config | Renderer | Profile, import("../../domain/errors").ProfileNotFound | ProfileNoneActive | import("../../domain/errors").ProfileInvalidName | import("../../domain/errors").Generic, {
+    readonly name: Option.Option<string>;
+}>;

package/dist/src/cli/profile/show.js

@@ -0,0 +1,40 @@
+import { Args, Command } from '@effect/cli';
+import { Effect, Option } from 'effect';
+import { ProfileNoneActive } from '../../domain/errors';
+import { Config } from '../../services/Config';
+import { Profile } from '../../services/Profile';
+import { Renderer } from '../../services/Renderer';
+import { formatDateTime } from '../../services/Renderer/datetime';
+const nameArg = Args.text({ name: 'name' }).pipe(Args.optional);
+export const show = Command.make('show', { name: nameArg }, ({ name }) => Effect.gen(function* () {
+    const profile = yield* Profile;
+    const config = yield* Config;
+    const renderer = yield* Renderer;
+    let target = Option.getOrElse(name, () => '');
+    if (!target) {
+        const current = yield* profile.current;
+        if (!current) {
+            return yield* Effect.fail(new ProfileNoneActive({
+                message: 'no profile specified and no active profile',
+                hint: 'run `mxs profile use <name>` or pass a profile name',
+            }));
+        }
+        target = current;
+    }
+    yield* profile.validateName(target);
+    // Profile.show emits ProfileNotFound when the profile dir is missing.
+    yield* profile.show(target);
+    const cfg = yield* config.readProfileConfig(target);
+    const creds = yield* config.readProfileCredentials(target);
+    const expiresAt = creds?.expires_at ?? null;
+    const expiresHuman = expiresAt !== null ? formatDateTime(expiresAt, { style: 'both' }) : null;
+    yield* renderer.emitSuccess({
+        name: target,
+        api_url: cfg.api_url ?? null,
+        production: cfg.production ?? false,
+        user: creds?.user ?? null,
+        expires_at: expiresAt,
+        expires_at_human: expiresHuman,
+        authenticated: creds !== null,
+    });
+}));

package/dist/src/cli/profile/use.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@effect/cli';
+import { Profile } from '../../services/Profile';
+import { Renderer } from '../../services/Renderer';
+export declare const use: Command.Command<"use", Renderer | Profile, import("../../domain/errors").ProfileNotFound | import("../../domain/errors").ProfileInvalidName | import("../../domain/errors").Generic, {
+    readonly name: string;
+}>;

package/dist/src/cli/profile/use.js

@@ -0,0 +1,11 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Profile } from '../../services/Profile';
+import { Renderer } from '../../services/Renderer';
+const name = Args.text({ name: 'name' });
+export const use = Command.make('use', { name }, ({ name }) => Effect.gen(function* () {
+    const profile = yield* Profile;
+    const renderer = yield* Renderer;
+    yield* profile.use(name);
+    yield* renderer.emitInfo(`mxs: active profile is now '${name}'`);
+}));

package/dist/src/cli/profile/view.d.ts

@@ -0,0 +1,8 @@
+import type { View } from '../../services/Renderer/view';
+export interface ProfileListRow {
+    readonly current: string;
+    readonly name: string;
+    readonly api_url: string;
+    readonly production: string;
+}
+export declare const profileListView: View<readonly ProfileListRow[]>;

package/dist/src/cli/profile/view.js

@@ -0,0 +1,21 @@
+import { ANSI, dim, renderTable, wrap } from '../ui';
+export const profileListView = {
+    kind: 'profile-list',
+    modes: new Set(['readable', 'llm']),
+    readable: (rows, { color }) => {
+        if (rows.length === 0)
+            return '';
+        return renderTable([
+            { key: 'name', label: 'profile' },
+            { key: 'api_url', label: 'api url' },
+            { key: 'production', label: 'prod' },
+        ], rows.map((r) => ({
+            name: r.current === '*' ? wrap(ANSI.bold, r.name, color) : r.name,
+            api_url: r.api_url || dim('—', color),
+            production: r.production === 'yes' ? 'yes' : dim('—', color),
+        })), {
+            color,
+            prefix: (i) => rows[i].current === '*' ? wrap(ANSI.cyan, '●', color) : ' ',
+        });
+    },
+};

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

@@ -0,0 +1,56 @@
+import { Options } from '@effect/cli';
+import { FileSystem } from '@effect/platform';
+import { Effect, Option } from 'effect';
+import { ValidationFailed } from '../../domain/errors';
+export declare const name: Options.Options<Option.Option<string>>;
+export declare const description: Options.Options<Option.Option<string>>;
+export declare const previewUrl: Options.Options<Option.Option<string>>;
+export declare const docUrl: Options.Options<Option.Option<string>>;
+export declare const projectUrl: Options.Options<Option.Option<string>>;
+export declare const avatar: Options.Options<Option.Option<string>>;
+export declare const images: Options.Options<Option.Option<string>>;
+export declare const text: Options.Options<Option.Option<string>>;
+export declare const file: Options.Options<Option.Option<string>>;
+export declare const openFlag: Options.Options<boolean>;
+export declare const silentFlag: Options.Options<boolean>;
+export declare const projectWriteOptions: {
+    name: Options.Options<Option.Option<string>>;
+    description: Options.Options<Option.Option<string>>;
+    previewUrl: Options.Options<Option.Option<string>>;
+    docUrl: Options.Options<Option.Option<string>>;
+    projectUrl: Options.Options<Option.Option<string>>;
+    avatar: Options.Options<Option.Option<string>>;
+    images: Options.Options<Option.Option<string>>;
+    text: Options.Options<Option.Option<string>>;
+    file: Options.Options<Option.Option<string>>;
+    open: Options.Options<boolean>;
+    silent: Options.Options<boolean>;
+};
+export interface ProjectWriteOptionsParsed {
+    readonly name: Option.Option<string>;
+    readonly description: Option.Option<string>;
+    readonly previewUrl: Option.Option<string>;
+    readonly docUrl: Option.Option<string>;
+    readonly projectUrl: Option.Option<string>;
+    readonly avatar: Option.Option<string>;
+    readonly images: Option.Option<string>;
+    readonly text: Option.Option<string>;
+    readonly file: Option.Option<string>;
+    readonly open: boolean;
+    readonly silent: boolean;
+}
+export interface ProjectFlagInputs {
+    readonly name?: string;
+    readonly description?: string;
+    readonly previewUrl?: string | null;
+    readonly docUrl?: string | null;
+    readonly projectUrl?: string | null;
+    readonly avatar?: string | null;
+    readonly images?: string[] | null;
+    readonly text?: string | null;
+    readonly file?: string;
+}
+export declare const toProjectFlagInputs: (opts: ProjectWriteOptionsParsed) => ProjectFlagInputs;
+export declare const buildProjectPayload: (flags: ProjectFlagInputs) => Effect.Effect<Record<string, unknown>, ValidationFailed, FileSystem.FileSystem>;
+export declare const extractId: (res: unknown) => string | undefined;
+export declare const editableFieldsOf: (raw: Record<string, unknown>) => Record<string, unknown>;

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

@@ -0,0 +1,130 @@
+import { Options } from '@effect/cli';
+import { FileSystem } from '@effect/platform';
+import { Effect, Option } from 'effect';
+import { ValidationFailed } from '../../domain/errors';
+const optional = (self) => Options.optional(self);
+const unwrap = (value) => Option.getOrUndefined(value);
+export const name = optional(Options.text('name'));
+export const description = optional(Options.text('description'));
+export const previewUrl = optional(Options.text('preview-url'));
+export const docUrl = optional(Options.text('doc-url'));
+export const projectUrl = optional(Options.text('project-url'));
+export const avatar = optional(Options.text('avatar'));
+export const images = optional(Options.text('images'));
+export const text = optional(Options.text('text'));
+export const file = optional(Options.text('file'));
+export const openFlag = Options.boolean('open').pipe(Options.withDescription('After success, open the admin edit page in the default browser.'));
+export const silentFlag = Options.boolean('silent').pipe(Options.withDescription('On success, emit a minimal `ok` instead of the full server response.'));
+const parseCsv = (v) => {
+    if (v === undefined)
+        return undefined;
+    const parts = v
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+    return parts;
+};
+export const projectWriteOptions = {
+    name,
+    description,
+    previewUrl,
+    docUrl,
+    projectUrl,
+    avatar,
+    images,
+    text,
+    file,
+    open: openFlag,
+    silent: silentFlag,
+};
+export const toProjectFlagInputs = (opts) => ({
+    name: unwrap(opts.name),
+    description: unwrap(opts.description),
+    previewUrl: unwrap(opts.previewUrl),
+    docUrl: unwrap(opts.docUrl),
+    projectUrl: unwrap(opts.projectUrl),
+    avatar: unwrap(opts.avatar),
+    images: parseCsv(unwrap(opts.images)),
+    text: unwrap(opts.text),
+    file: unwrap(opts.file),
+});
+const PROJECT_KEYS = [
+    'name',
+    'description',
+    'previewUrl',
+    'docUrl',
+    'projectUrl',
+    'avatar',
+    'images',
+    'text',
+];
+const readJsonFile = (path) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const raw = yield* fs.readFileString(path).pipe(Effect.mapError((cause) => new ValidationFailed({
+        message: `cannot read --file ${path}`,
+        details: { cause: String(cause) },
+    })));
+    const parsed = yield* Effect.try({
+        try: () => JSON.parse(raw),
+        catch: (err) => new ValidationFailed({
+            message: `--file ${path} is not valid JSON`,
+            details: { cause: String(err) },
+        }),
+    });
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return yield* Effect.fail(new ValidationFailed({
+            message: `--file ${path} must contain a JSON object`,
+        }));
+    }
+    return parsed;
+});
+const pickProjectFields = (raw) => {
+    const out = {};
+    for (const key of PROJECT_KEYS) {
+        if (key in raw)
+            out[key] = raw[key];
+    }
+    return out;
+};
+export const buildProjectPayload = (flags) => Effect.gen(function* () {
+    const fileMerge = flags.file
+        ? pickProjectFields(yield* readJsonFile(flags.file))
+        : {};
+    const payload = { ...fileMerge };
+    if (flags.name !== undefined)
+        payload.name = flags.name;
+    if (flags.description !== undefined)
+        payload.description = flags.description;
+    if (flags.previewUrl !== undefined)
+        payload.previewUrl = flags.previewUrl;
+    if (flags.docUrl !== undefined)
+        payload.docUrl = flags.docUrl;
+    if (flags.projectUrl !== undefined)
+        payload.projectUrl = flags.projectUrl;
+    if (flags.avatar !== undefined)
+        payload.avatar = flags.avatar;
+    if (flags.images !== undefined)
+        payload.images = flags.images;
+    if (flags.text !== undefined)
+        payload.text = flags.text;
+    return payload;
+});
+export const extractId = (res) => {
+    if (!res || typeof res !== 'object')
+        return undefined;
+    const r = res;
+    if (typeof r.id === 'string')
+        return r.id;
+    if (typeof r._id === 'string')
+        return r._id;
+    if (r.data && typeof r.data === 'object')
+        return extractId(r.data);
+    return undefined;
+};
+export const editableFieldsOf = (raw) => {
+    const out = {};
+    for (const key of PROJECT_KEYS) {
+        out[key] = key in raw ? (raw[key] ?? null) : null;
+    }
+    return out;
+};

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

@@ -0,0 +1,17 @@
+import { Command } from '@effect/cli';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+export declare const create: Command.Command<"create", import("@effect/platform/FileSystem").FileSystem | Api | Renderer | Resolver, import("../../services/Api").ApiError, {
+    readonly name: import("effect/Option").Option<string>;
+    readonly description: import("effect/Option").Option<string>;
+    readonly previewUrl: import("effect/Option").Option<string>;
+    readonly docUrl: import("effect/Option").Option<string>;
+    readonly projectUrl: import("effect/Option").Option<string>;
+    readonly avatar: import("effect/Option").Option<string>;
+    readonly images: import("effect/Option").Option<string>;
+    readonly text: import("effect/Option").Option<string>;
+    readonly file: import("effect/Option").Option<string>;
+    readonly open: boolean;
+    readonly silent: boolean;
+}>;

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

@@ -0,0 +1,25 @@
+import { Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { openAdminEdit } from '../../domain/admin-link';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+import { buildProjectPayload, extractId, projectWriteOptions, toProjectFlagInputs, } from './_flags';
+export const create = Command.make('create', projectWriteOptions, (opts) => Effect.gen(function* () {
+    const flags = toProjectFlagInputs(opts);
+    const payload = yield* buildProjectPayload(flags);
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const resolver = yield* Resolver;
+    const res = yield* api.request('/projects', {
+        method: 'POST',
+        body: payload,
+    });
+    yield* resolver.invalidate('project');
+    yield* renderer.emitSuccess(opts.silent ? { ok: true } : res);
+    if (opts.open) {
+        const id = extractId(res);
+        if (id)
+            yield* openAdminEdit('projects', id);
+    }
+})).pipe(Command.withDescription('create a project'));

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

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

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

@@ -0,0 +1,22 @@
+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 { Resolver } from '../../services/Resolver';
+const nameOrId = Args.text({ name: 'nameOrId' });
+const force = Options.boolean('force').pipe(Options.withDescription('skip the non-TTY guard'));
+export const del = Command.make('delete', { nameOrId, force }, ({ nameOrId, 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 resolver = yield* Resolver;
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const id = yield* resolver.resolveProjectId(nameOrId);
+    yield* api.request(`/projects/${id}`, { method: 'DELETE' });
+    yield* resolver.invalidate('project');
+    yield* renderer.emitSuccess({ deleted: id });
+})).pipe(Command.withDescription('delete a project'));

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

@@ -0,0 +1,11 @@
+import { Command } from '@effect/cli';
+import { ValidationJson } from '../../domain/errors';
+import { Api } from '../../services/Api';
+import { Editor } from '../../services/Editor';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+export declare const edit: Command.Command<"edit", Api | Renderer | Resolver | Editor, ValidationJson | import("../../services/Api").ApiError, {
+    readonly nameOrId: string;
+    readonly open: boolean;
+    readonly silent: boolean;
+}>;

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

@@ -0,0 +1,61 @@
+import { Args, Command, Options } from '@effect/cli';
+import { Effect } from 'effect';
+import { openAdminEdit } from '../../domain/admin-link';
+import { ValidationJson } from '../../domain/errors';
+import { Api } from '../../services/Api';
+import { Editor } from '../../services/Editor';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+import { editableFieldsOf } from './_flags';
+const nameOrId = Args.text({ name: 'nameOrId' });
+const openFlag = Options.boolean('open').pipe(Options.withDescription('After success, open the admin edit page in the default browser.'));
+const silentFlag = Options.boolean('silent').pipe(Options.withDescription('On success, emit a minimal `ok` instead of the full server response.'));
+const unwrapDoc = (raw) => {
+    if (!raw || typeof raw !== 'object')
+        return {};
+    const r = raw;
+    if (r.data && typeof r.data === 'object' && !Array.isArray(r.data)) {
+        return r.data;
+    }
+    return r;
+};
+const formatJson = (value) => `${JSON.stringify(value, null, 2)}\n`;
+const parseEnvelope = (raw) => {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('expected a JSON object');
+    }
+    return parsed;
+};
+export const edit = Command.make('edit', { nameOrId, open: openFlag, silent: silentFlag }, ({ nameOrId, open, silent }) => Effect.gen(function* () {
+    const api = yield* Api;
+    const editor = yield* Editor;
+    const renderer = yield* Renderer;
+    const resolver = yield* Resolver;
+    const id = yield* resolver.resolveProjectId(nameOrId);
+    const current = unwrapDoc(yield* api.request(`/projects/${id}`));
+    const initial = formatJson(editableFieldsOf(current));
+    const next = yield* editor.openEditor({
+        filename: `project-${id}.json`,
+        initialContent: initial,
+    });
+    if (next.trim() === initial.trim()) {
+        yield* renderer.emitInfo('no changes');
+        return;
+    }
+    const parsed = yield* Effect.try({
+        try: () => parseEnvelope(next),
+        catch: (err) => new ValidationJson({
+            message: err instanceof Error ? err.message : String(err),
+            cause: err,
+        }),
+    });
+    const res = yield* api.request(`/projects/${id}`, {
+        method: 'PATCH',
+        body: parsed,
+    });
+    yield* resolver.invalidate('project');
+    yield* renderer.emitSuccess(silent ? { ok: true } : res);
+    if (open)
+        yield* openAdminEdit('projects', id);
+})).pipe(Command.withDescription('edit a project via $EDITOR (JSON envelope)'));

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

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

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

@@ -0,0 +1,14 @@
+import { Args, Command } from '@effect/cli';
+import { Effect } from 'effect';
+import { Api } from '../../services/Api';
+import { Renderer } from '../../services/Renderer';
+import { Resolver } from '../../services/Resolver';
+const nameOrId = Args.text({ name: 'nameOrId' });
+export const get = Command.make('get', { nameOrId }, ({ nameOrId }) => Effect.gen(function* () {
+    const api = yield* Api;
+    const renderer = yield* Renderer;
+    const resolver = yield* Resolver;
+    const id = yield* resolver.resolveProjectId(nameOrId);
+    const res = yield* api.request(`/projects/${id}`);
+    yield* renderer.emitSuccess(res);
+})).pipe(Command.withDescription('get a project by name or id'));

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

@@ -0,0 +1,43 @@
+import { Command } from '@effect/cli';
+export declare const projectCmd: Command.Command<"project", import("@effect/platform/FileSystem").FileSystem | import("../../services/Api").Api | import("../ai/_poll").Renderer | import("../../services/Resolver").Resolver | import("../../services/Editor").Editor, import("../../domain/errors").ValidationJson | import("../../services/Api").ApiError, {
+    readonly subcommand: import("effect/Option").Option<{
+        readonly name: import("effect/Option").Option<string>;
+        readonly description: import("effect/Option").Option<string>;
+        readonly previewUrl: import("effect/Option").Option<string>;
+        readonly docUrl: import("effect/Option").Option<string>;
+        readonly projectUrl: import("effect/Option").Option<string>;
+        readonly avatar: import("effect/Option").Option<string>;
+        readonly images: import("effect/Option").Option<string>;
+        readonly text: import("effect/Option").Option<string>;
+        readonly file: import("effect/Option").Option<string>;
+        readonly open: boolean;
+        readonly silent: boolean;
+    } | {
+        readonly nameOrId: string;
+        readonly force: boolean;
+    } | {
+        readonly nameOrId: string;
+        readonly open: boolean;
+        readonly silent: boolean;
+    } | {
+        readonly nameOrId: string;
+    } | {
+        readonly page: import("effect/Option").Option<number>;
+        readonly size: import("effect/Option").Option<number>;
+    } | {
+        readonly name: import("effect/Option").Option<string>;
+        readonly description: import("effect/Option").Option<string>;
+        readonly previewUrl: import("effect/Option").Option<string>;
+        readonly docUrl: import("effect/Option").Option<string>;
+        readonly projectUrl: import("effect/Option").Option<string>;
+        readonly avatar: import("effect/Option").Option<string>;
+        readonly images: import("effect/Option").Option<string>;
+        readonly text: import("effect/Option").Option<string>;
+        readonly file: import("effect/Option").Option<string>;
+        readonly open: boolean;
+        readonly silent: boolean;
+        readonly nameOrId: string;
+    } | {
+        readonly nameOrId: string;
+    }>;
+}>;

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

@@ -0,0 +1,52 @@
+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 { update } from './update';
+import { viewCmd } from './view-cmd';
+const help = registerCommandHelp({
+    name: 'project',
+    description: 'manage portfolio projects',
+    skillChapter: 'commands-project',
+    verbs: [
+        {
+            name: 'list',
+            args: ['[--page <n>]', '[--size <n>]'],
+            description: 'list projects',
+        },
+        {
+            name: 'get',
+            args: ['<nameOrId>'],
+            description: 'show a single project (raw)',
+        },
+        {
+            name: 'view',
+            args: ['<nameOrId>'],
+            description: 'show a single project (rendered)',
+        },
+        {
+            name: 'create',
+            args: ['--name <s>', '--description <s>', '[--file <path>]', '...'],
+            description: 'create a project',
+        },
+        {
+            name: 'edit',
+            args: ['<nameOrId>'],
+            description: 'edit a project via $EDITOR (JSON envelope)',
+        },
+        {
+            name: 'update',
+            args: ['<nameOrId>', '[--name ...]', '...'],
+            description: 'partially update a project',
+        },
+        {
+            name: 'delete',
+            args: ['<nameOrId>', '[--force]'],
+            description: 'delete a project',
+        },
+    ],
+});
+export const projectCmd = Command.make('project').pipe(Command.withDescription(help.description), Command.withSubcommands([list, get, viewCmd, create, edit, update, del]));