deploylog 0.2.2 → 0.4.0

package/dist/index.js

@@ -1,15 +1,22 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { setApiKey, setApiUrl, getConfigPath, clearConfig } from './config.js';
-import { listProjects, listEntries, createEntry, summarize, ApiError, } from './api.js';
+import { setApiKey, setApiUrl, getApiUrl, getConfigPath, clearConfig } from './config.js';
+import { listProjects, listEntries, createProject, importGithub, whoami, ApiError, } from './api.js';
 import { readProjectConfig } from './project-config.js';
-import { isGitRepo, getLastTag, getHeadVersion, getCommitsSince, defaultTitleFromGit, formatCommitsAsMarkdown, } from './git.js';
+import { runPush, defaultPushDeps } from './push.js';
+import { runSetPublished, runView, runEdit, runDelete, defaultEntryCommandDeps, } from './entry-commands.js';
+import { runInit, defaultInitDeps } from './init.js';
+import { runOpen } from './open.js';
 const program = new Command();
 program
     .name('deploylog')
     .description('Push changelog entries from the terminal')
-    .version('0.2.0');
+    // Without positional options, the global -V/--version greedily matches
+    // `push --version 1.4.0` and prints the CLI version instead of setting the
+    // entry's semver. Program options now must precede the subcommand.
+    .enablePositionalOptions()
+    .version('0.4.0');
 // ─── login ──────────────────────────────────────────────────────────────────
 program
     .command('login')
@@ -69,12 +76,18 @@ program
     console.log(chalk.green('Logged out. Credentials removed.'));
 });
 // ─── projects ───────────────────────────────────────────────────────────────
-program
+const projectsCmd = program
     .command('projects')
+    .alias('proj')
     .description('List projects in your organization')
-    .action(async () => {
+    .option('--json', 'Output JSON (machine-readable, never prompts)')
+    .action(async (opts) => {
     try {
         const projects = await listProjects();
+        if (opts.json) {
+            printJson(projects);
+            return;
+        }
         if (projects.length === 0) {
             console.log(chalk.dim('No projects found.'));
             return;
@@ -85,18 +98,92 @@ program
         }
     }
     catch (err) {
-        handleError(err);
+        handleError(err, opts.json);
+    }
+});
+projectsCmd
+    .command('create <name>')
+    .description('Create a new project (slug is generated from the name)')
+    .option('--url <url>', 'Project website URL')
+    .option('--json', 'Output JSON (machine-readable, never prompts)')
+    .action(async (name, opts, command) => {
+    // The parent `projects` command also defines --json and commander hands
+    // the flag to whichever parsed it — honor both.
+    const json = Boolean(opts.json || command.optsWithGlobals().json);
+    try {
+        const project = await createProject(name, opts.url);
+        if (json) {
+            printJson(project);
+            return;
+        }
+        console.log(`${chalk.green('✓')} Project created: ${chalk.bold(project.name)}`);
+        console.log(`  Slug: ${chalk.cyan(project.slug)}`);
+        console.log(chalk.dim(`  Public changelog: ${getApiUrl()}/p/${project.slug}/changelog`));
+        console.log(chalk.dim('  Run `deploylog init` in the repo to wire pushes to it.'));
+    }
+    catch (err) {
+        handleError(err, json);
+    }
+});
+// ─── whoami ─────────────────────────────────────────────────────────────────
+program
+    .command('whoami')
+    .description('Show the authenticated org, plan, API key, and AI usage')
+    .option('--json', 'Output JSON (machine-readable, never prompts)')
+    .action(async (opts) => {
+    try {
+        const me = await whoami();
+        if (opts.json) {
+            printJson({ ...me, api_url: getApiUrl(), config_path: getConfigPath() });
+            return;
+        }
+        const limitLabel = me.ai_usage.limit === null ? '∞' : String(me.ai_usage.limit);
+        console.log(`${chalk.bold(me.organization.name)}  ${chalk.dim(me.organization.slug)}`);
+        console.log(`  Plan:     ${chalk.cyan(me.organization.plan ?? 'free')}`);
+        console.log(`  API key:  ${me.api_key.name}  ${chalk.dim(`${me.api_key.prefix}…  [${me.api_key.permissions.join(', ')}]`)}`);
+        if (me.api_key.last_used_at) {
+            console.log(chalk.dim(`  Last used: ${me.api_key.last_used_at}`));
+        }
+        console.log(`  AI usage: ${me.ai_usage.used}/${limitLabel} this month ${chalk.dim(`(${me.ai_usage.month_key})`)}`);
+        console.log(chalk.dim(`  API URL:  ${getApiUrl()}`));
+        console.log(chalk.dim(`  Config:   ${getConfigPath()}`));
+    }
+    catch (err) {
+        handleError(err, opts.json);
     }
 });
 // ─── list ───────────────────────────────────────────────────────────────────
 program
     .command('list')
+    .alias('ls')
     .description('List recent entries for a project')
     .option('-p, --project <slug>', 'Project slug (or set in .deploylog.yml)')
+    .option('--drafts', 'Only drafts')
+    .option('--published', 'Only published entries')
+    .option('-T, --type <type>', 'Filter by entry type')
+    .option('-n, --limit <n>', 'Max entries to show (1-50)', (v) => parseInt(v, 10))
+    .option('--json', 'Output JSON (machine-readable, never prompts)')
     .action(async (opts) => {
     try {
+        if (opts.drafts && opts.published) {
+            console.error(chalk.red('Use at most one of --drafts / --published.'));
+            process.exit(1);
+        }
         const slug = resolveProject(opts.project);
-        const entries = await listEntries(slug);
+        const filters = {};
+        if (opts.drafts)
+            filters.status = 'draft';
+        if (opts.published)
+            filters.status = 'published';
+        if (opts.type)
+            filters.type = opts.type;
+        if (opts.limit !== undefined)
+            filters.limit = opts.limit;
+        const entries = await listEntries(slug, filters);
+        if (opts.json) {
+            printJson(entries);
+            return;
+        }
         if (entries.length === 0) {
             console.log(chalk.dim('No entries found.'));
             return;
@@ -113,10 +200,57 @@ program
                 day: 'numeric',
             });
             console.log(`  ${status}  ${e.title}  ${type}  ${version}  ${chalk.dim(date)}`);
+            console.log(`    ${chalk.dim(`${e.slug}  ${e.id}`)}`);
+        }
+        const effectiveLimit = filters.limit ?? 50;
+        if (entries.length >= effectiveLimit) {
+            console.log(chalk.dim(`\nShowing the ${entries.length} most recent. Older entries: narrow with --drafts / --published / --type, or reference by id.`));
+        }
+    }
+    catch (err) {
+        handleError(err, opts.json);
+    }
+});
+// ─── view ───────────────────────────────────────────────────────────────────
+program
+    .command('view <entry>')
+    .alias('show')
+    .description('Show a full entry (slug or id), including its markdown body')
+    .option('-p, --project <slug>', 'Project slug (or set in .deploylog.yml)')
+    .option('--json', 'Output JSON (machine-readable, never prompts)')
+    .action(async (ref, opts) => {
+    try {
+        const result = await runView({ ref, project: opts.project });
+        if (result.kind !== 'found') {
+            if (opts.json) {
+                printJsonError('NOT_FOUND', result.message);
+            }
+            else {
+                console.error(chalk.red(result.message));
+            }
+            process.exit(1);
         }
+        const e = result.entry;
+        if (opts.json) {
+            printJson(e);
+            return;
+        }
+        const status = e.published ? chalk.green('published') : chalk.yellow('draft');
+        console.log(`${chalk.bold(e.title)}  ${status}`);
+        console.log(chalk.dim(`  id:      ${e.id}`));
+        console.log(chalk.dim(`  slug:    ${e.slug}`));
+        if (e.entry_type)
+            console.log(chalk.dim(`  type:    ${e.entry_type}`));
+        if (e.version)
+            console.log(chalk.dim(`  version: v${e.version}`));
+        console.log(chalk.dim(`  created: ${e.created_at}`));
+        if (e.published_at)
+            console.log(chalk.dim(`  published: ${e.published_at}`));
+        console.log();
+        console.log(e.body_markdown);
     }
     catch (err) {
-        handleError(err);
+        handleError(err, opts.json);
     }
 });
 // ─── push ───────────────────────────────────────────────────────────────────
@@ -126,125 +260,350 @@ program
     .option('-t, --title <title>', 'Entry title (required unless --from-git or --ai-summarize)')
     .option('-b, --body <markdown>', 'Entry body (Markdown)')
     .option('-p, --project <slug>', 'Project slug (or set in .deploylog.yml)')
-    .option('--type <type>', 'Entry type: feature, fix, improvement, breaking, announcement')
+    .option('-T, --type <type>', 'Entry type: feature, fix, improvement, breaking, announcement')
     .option('--version <version>', 'Semver version (e.g. 1.2.3)')
-    .option('--publish', 'Publish immediately (default: draft)')
-    .option('--draft', 'Save as draft (default)')
-    .option('--from-git', 'Derive title/body from commits since the last tag')
-    .option('--ai-summarize', 'Rewrite the entry with Claude Haiku (user-friendly release notes)')
+    .option('-P, --publish', 'Publish immediately (default: draft)')
+    .option('-D, --draft', 'Save as draft (default)')
+    .option('-g, --from-git', 'Derive title/body from commits since the last tag')
+    .option('--git', 'Alias of --from-git')
+    .option('-a, --ai-summarize', 'Rewrite the entry with Claude Haiku (user-friendly release notes)')
+    .option('--ai', 'Alias of --ai-summarize')
     .option('-y, --yes', 'Skip interactive confirmation for AI-generated content')
+    .option('--json', 'Output JSON (machine-readable, never prompts)')
     .action(async (opts) => {
     try {
-        const slug = resolveProject(opts.project);
-        const projectConfig = readProjectConfig();
-        // Gather source material (commits + version) if --from-git.
-        let commits = [];
-        let gitVersion = null;
-        let gitTitle = null;
-        let gitBody = null;
-        if (opts.fromGit) {
-            if (!isGitRepo()) {
-                console.error(chalk.red('Not in a git repository. Remove --from-git or cd to a repo.'));
-                process.exit(1);
+        // JSON mode is a machine contract: no prompts (non-TTY path), progress
+        // and notices to stderr, stdout reserved for the data payload.
+        const deps = opts.json
+            ? {
+                ...defaultPushDeps,
+                isTTY: false,
+                out: {
+                    progressStart: (msg) => process.stderr.write(`${msg} `),
+                    progressDone: (msg) => process.stderr.write(`${msg}\n`),
+                    notice: (msg) => console.error(msg),
+                    aiPreview: () => { },
+                },
             }
-            const lastTag = getLastTag();
-            commits = getCommitsSince(lastTag);
-            gitVersion = getHeadVersion();
-            gitTitle = defaultTitleFromGit(gitVersion, lastTag);
-            gitBody = formatCommitsAsMarkdown(commits);
-            if (commits.length === 0 && !opts.body && !opts.aiSummarize) {
-                console.error(chalk.yellow(lastTag
-                    ? `No commits since tag ${lastTag}. Nothing to summarize.`
-                    : 'No commits found on HEAD.'));
+            : defaultPushDeps;
+        const result = await runPush(opts, deps);
+        switch (result.kind) {
+            case 'created': {
+                const entry = result.entry;
+                if (opts.json) {
+                    printJson(entry);
+                    break;
+                }
+                const status = entry.published ? chalk.green('Published') : chalk.yellow('Draft');
+                console.log(`\n${chalk.green('✓')} Entry created: ${chalk.bold(entry.title)}`);
+                console.log(`  Status: ${status}`);
+                console.log(`  Slug:   ${chalk.dim(entry.slug)}`);
+                if (entry.version)
+                    console.log(`  Version: ${chalk.dim(`v${entry.version}`)}`);
+                break;
+            }
+            case 'cancelled':
+                // User declined at the confirm prompt — a clean, non-error stop.
+                console.log(chalk.yellow(result.message));
+                break;
+            case 'no-commits':
+                // Valid command, nothing to do — warn (yellow) and exit non-zero.
+                if (opts.json)
+                    printJsonError('NO_COMMITS', result.message);
+                else
+                    console.error(chalk.yellow(result.message));
+                process.exit(1);
+            default:
+                // no-ai-source | missing-fields — a misuse refusal.
+                if (opts.json)
+                    printJsonError(result.kind.toUpperCase().replace(/-/g, '_'), result.message);
+                else
+                    console.error(chalk.red(result.message));
                 process.exit(1);
+        }
+    }
+    catch (err) {
+        handleError(err, opts.json);
+    }
+});
+// ─── edit ───────────────────────────────────────────────────────────────────
+program
+    .command('edit <entry>')
+    .description('Edit an entry (slug or id) via flags, --body-file, or $EDITOR')
+    .option('-p, --project <slug>', 'Project slug (or set in .deploylog.yml)')
+    .option('-t, --title <title>', "New title (may change a draft's slug)")
+    .option('-T, --type <type>', 'Entry type: feature, fix, improvement, breaking, announcement')
+    .option('--version <version>', 'Semver version (pass "" to clear)')
+    .option('-b, --body <markdown>', 'New body (Markdown)')
+    .option('--body-file <path>', 'Read the new body from a file (- for stdin)')
+    .option('--json', 'Output JSON (machine-readable, never prompts)')
+    .action(async (ref, opts) => {
+    try {
+        // JSON mode never opens $EDITOR — force the non-interactive path.
+        const deps = opts.json ? { ...defaultEntryCommandDeps, isTTY: false } : undefined;
+        const result = await runEdit({ ref, ...opts }, deps);
+        switch (result.kind) {
+            case 'updated': {
+                const e = result.entry;
+                if (opts.json) {
+                    printJson({ ...e, previous_slug: result.previousSlug });
+                    break;
+                }
+                console.log(`${chalk.green('✓')} Updated: ${chalk.bold(e.title)}`);
+                if (e.slug !== result.previousSlug) {
+                    console.log(chalk.yellow(`  Slug changed from '${result.previousSlug}' to '${e.slug}'.`));
+                    console.log(chalk.dim('  Scripts referencing the old slug should switch to the id.'));
+                }
+                else {
+                    console.log(`  Slug: ${chalk.dim(e.slug)}`);
+                }
+                break;
             }
+            case 'unchanged':
+            case 'cancelled':
+                if (opts.json)
+                    printJsonError(result.kind.toUpperCase(), result.message);
+                else
+                    console.log(chalk.yellow(result.message));
+                break;
+            case 'body-rejected':
+                if (opts.json)
+                    printJsonError('VALIDATION_ERROR', result.message);
+                else
+                    console.error(chalk.red(result.message));
+                process.exit(1);
+            default:
+                if (opts.json)
+                    printJsonError(result.kind.toUpperCase().replace(/-/g, '_'), result.message);
+                else
+                    console.error(chalk.red(result.message));
+                process.exit(1);
+        }
+    }
+    catch (err) {
+        handleError(err, opts.json);
+    }
+});
+// ─── import ─────────────────────────────────────────────────────────────────
+const importCmd = program
+    .command('import')
+    .description('Import entries from an external source');
+importCmd
+    .command('github <repo>')
+    .description('Import GitHub releases as draft entries (owner/repo or a github.com URL)')
+    .option('-p, --project <slug>', 'Project slug (or set in .deploylog.yml)')
+    .option('--token <token>', 'GitHub personal access token for private repos / rate limits (or set DEPLOYLOG_GITHUB_TOKEN); never stored')
+    .option('--json', 'Output JSON (machine-readable, never prompts)')
+    .action(async (repo, opts) => {
+    try {
+        const slug = resolveProject(opts.project);
+        const token = opts.token ?? process.env.DEPLOYLOG_GITHUB_TOKEN;
+        const result = await importGithub(slug, repo, token);
+        if (opts.json) {
+            printJson(result);
+            return;
         }
-        // Build the entry (with optional AI rewrite).
-        let title = opts.title ?? gitTitle ?? '';
-        let body = opts.body ?? gitBody ?? '';
-        let entryType = opts.type ?? projectConfig?.default_type ?? null;
-        const version = opts.version ?? gitVersion ?? undefined;
-        if (opts.aiSummarize) {
-            const hasSource = commits.length > 0 || (opts.body && opts.body.trim().length > 0);
-            if (!hasSource) {
-                console.error(chalk.red('--ai-summarize needs source material. Pass --from-git or provide --body as raw notes.'));
+        if (result.imported === 0 && result.skipped === 0) {
+            console.log(chalk.yellow('No releases found to import.'));
+            return;
+        }
+        console.log(`${chalk.green('✓')} Imported ${chalk.bold(String(result.imported))} release${result.imported === 1 ? '' : 's'} as drafts` +
+            (result.skipped > 0 ? chalk.dim(` (${result.skipped} already imported, skipped)`) : ''));
+        if (result.imported > 0) {
+            console.log(chalk.dim('  Review with `deploylog list --drafts`, then `deploylog publish <slug>`.'));
+        }
+    }
+    catch (err) {
+        handleError(err, opts.json);
+    }
+});
+// ─── init ───────────────────────────────────────────────────────────────────
+program
+    .command('init')
+    .description('Scaffold a .deploylog.yml in this directory (project + optional default type)')
+    .option('-p, --project <slug>', 'Project slug (interactive pick if omitted)')
+    .option('-T, --type <type>', 'Default entry type for pushes from this repo')
+    .option('--force', 'Overwrite an existing .deploylog.yml')
+    .option('--json', 'Output JSON (machine-readable, never prompts)')
+    .action(async (opts) => {
+    try {
+        const deps = opts.json ? { ...defaultInitDeps, isTTY: false } : undefined;
+        const result = await runInit(opts, deps);
+        switch (result.kind) {
+            case 'written':
+                if (opts.json) {
+                    printJson({ path: result.path, project: result.project, default_type: result.defaultType ?? null });
+                    break;
+                }
+                console.log(`${chalk.green('✓')} Wrote ${result.path}`);
+                console.log(`  project: ${chalk.cyan(result.project)}`);
+                if (result.defaultType)
+                    console.log(`  default_type: ${chalk.cyan(result.defaultType)}`);
+                console.log(chalk.dim('  `deploylog push` in this directory now targets that project.'));
+                break;
+            case 'cancelled':
+                console.log(chalk.yellow(result.message));
+                break;
+            default:
+                if (opts.json)
+                    printJsonError(result.kind.toUpperCase().replace(/-/g, '_'), result.message);
+                else
+                    console.error(chalk.red(result.message));
                 process.exit(1);
-            }
-            process.stdout.write(chalk.dim('Summarizing with Claude Haiku... '));
-            const res = await summarize({
-                project_slug: slug,
-                commits: commits.map((c) => c.subject),
-                release_notes: opts.body,
-                version,
-            });
-            process.stdout.write(chalk.green('done\n'));
-            title = opts.title ?? res.summary.title;
-            body = res.summary.body_markdown;
-            entryType = opts.type ?? res.summary.entry_type;
-            printAiPreview(res.summary, res.usage);
-            if (!opts.yes && process.stdin.isTTY) {
-                const ok = await confirm('Publish this entry?');
-                if (!ok) {
-                    console.log(chalk.yellow('Cancelled. No entry was created.'));
-                    return;
+        }
+    }
+    catch (err) {
+        handleError(err, opts.json);
+    }
+});
+// ─── delete ─────────────────────────────────────────────────────────────────
+program
+    .command('delete <entry>')
+    .alias('rm')
+    .description('Delete an entry permanently (slug or id)')
+    .option('-p, --project <slug>', 'Project slug (or set in .deploylog.yml)')
+    .option('-y, --yes', 'Skip the confirmation prompt (required in non-interactive mode)')
+    .option('--json', 'Output JSON (machine-readable, never prompts)')
+    .action(async (ref, opts) => {
+    try {
+        // JSON mode never prompts — deletion then requires an explicit --yes.
+        const deps = opts.json ? { ...defaultEntryCommandDeps, isTTY: false } : undefined;
+        const result = await runDelete({ ref, project: opts.project, yes: opts.yes }, deps);
+        switch (result.kind) {
+            case 'deleted':
+                if (opts.json) {
+                    printJson({ id: result.id, title: result.title, deleted: true });
+                    break;
                 }
+                console.log(`${chalk.green('✓')} Deleted: ${chalk.bold(result.title)}`);
+                break;
+            case 'cancelled':
+                console.log(chalk.yellow(result.message));
+                break;
+            default:
+                if (opts.json)
+                    printJsonError(result.kind.toUpperCase().replace(/-/g, '_'), result.message);
+                else
+                    console.error(chalk.red(result.message));
+                process.exit(1);
+        }
+    }
+    catch (err) {
+        handleError(err, opts.json);
+    }
+});
+// ─── publish / unpublish ────────────────────────────────────────────────────
+program
+    .command('publish <entry>')
+    .alias('pub')
+    .description('Publish a draft entry (slug or id); sends the email digest on Pro')
+    .option('-p, --project <slug>', 'Project slug (or set in .deploylog.yml)')
+    .option('--json', 'Output JSON (machine-readable, never prompts)')
+    .action(async (ref, opts) => {
+    try {
+        const result = await runSetPublished({ ref, project: opts.project, publish: true });
+        switch (result.kind) {
+            case 'updated': {
+                const e = result.entry;
+                if (opts.json) {
+                    printJson(e);
+                    break;
+                }
+                if (!e.changed) {
+                    console.log(chalk.yellow(`Entry is already published — nothing to do.`));
+                    console.log(`  ${chalk.dim('Slug:')} ${e.slug}`);
+                    break;
+                }
+                console.log(`${chalk.green('✓')} Published: ${chalk.bold(e.title)}`);
+                console.log(`  Slug: ${chalk.dim(e.slug)}`);
+                console.log(chalk.dim('  Subscribers get the email digest (Pro plans, first publish only).'));
+                break;
             }
-            else if (!opts.yes) {
-                // Non-interactive shell (CI, piped stdin): there's no prompt to show,
-                // so make the unreviewed auto-proceed explicit. (BUG-019)
-                console.log(chalk.yellow('Non-interactive shell: proceeding with the AI-generated entry without confirmation.'));
-            }
+            default:
+                if (opts.json)
+                    printJsonError(result.kind.toUpperCase().replace(/-/g, '_'), result.message);
+                else
+                    console.error(chalk.red(result.message));
+                process.exit(1);
         }
-        if (!title || !body) {
-            console.error(chalk.red('Entry requires --title and --body (or --from-git / --ai-summarize to derive them).'));
-            process.exit(1);
+    }
+    catch (err) {
+        handleError(err, opts.json);
+    }
+});
+program
+    .command('unpublish <entry>')
+    .alias('unpub')
+    .description('Revert a published entry to draft (its public URL and feeds drop it)')
+    .option('-p, --project <slug>', 'Project slug (or set in .deploylog.yml)')
+    .option('--json', 'Output JSON (machine-readable, never prompts)')
+    .action(async (ref, opts) => {
+    try {
+        const result = await runSetPublished({ ref, project: opts.project, publish: false });
+        switch (result.kind) {
+            case 'updated': {
+                const e = result.entry;
+                if (opts.json) {
+                    printJson(e);
+                    break;
+                }
+                if (!e.changed) {
+                    console.log(chalk.yellow(`Entry is already a draft — nothing to do.`));
+                    break;
+                }
+                console.log(`${chalk.green('✓')} Unpublished: ${chalk.bold(e.title)}`);
+                console.log(chalk.dim('  The public page and feeds drop it (cached copies may lag a few minutes).\n' +
+                    '  Republishing sets a new publish date.'));
+                break;
+            }
+            default:
+                if (opts.json)
+                    printJsonError(result.kind.toUpperCase().replace(/-/g, '_'), result.message);
+                else
+                    console.error(chalk.red(result.message));
+                process.exit(1);
         }
-        if (opts.publish && opts.draft) {
-            console.log(chalk.yellow('Both --publish and --draft passed; saving as a draft.'));
+    }
+    catch (err) {
+        handleError(err, opts.json);
+    }
+});
+// ─── open ───────────────────────────────────────────────────────────────────
+program
+    .command('open [entry]')
+    .alias('o')
+    .description("Open the project's public changelog (or one entry's page) in the browser")
+    .option('-p, --project <slug>', 'Project slug (or set in .deploylog.yml)')
+    .option('--json', 'Output JSON (machine-readable, never prompts)')
+    .action(async (ref, opts) => {
+    try {
+        const result = await runOpen({ ref, project: opts.project });
+        switch (result.kind) {
+            case 'opened':
+                if (opts.json)
+                    printJson({ url: result.url, opened: true });
+                else
+                    console.log(chalk.dim(result.url));
+                break;
+            case 'printed':
+                if (opts.json)
+                    printJson({ url: result.url, opened: false });
+                else
+                    console.log(result.url);
+                break;
+            default:
+                if (opts.json)
+                    printJsonError(result.kind.toUpperCase().replace(/-/g, '_'), result.message);
+                else
+                    console.error(chalk.red(result.message));
+                process.exit(1);
         }
-        const entry = await createEntry(slug, {
-            title,
-            body_markdown: body,
-            entry_type: entryType,
-            version,
-            publish: opts.publish && !opts.draft,
-        });
-        const status = entry.published
-            ? chalk.green('Published')
-            : chalk.yellow('Draft');
-        console.log(`\n${chalk.green('✓')} Entry created: ${chalk.bold(entry.title)}`);
-        console.log(`  Status: ${status}`);
-        console.log(`  Slug:   ${chalk.dim(entry.slug)}`);
-        if (entry.version)
-            console.log(`  Version: ${chalk.dim(`v${entry.version}`)}`);
     }
     catch (err) {
-        handleError(err);
+        handleError(err, opts.json);
     }
 });
 // ─── helpers ────────────────────────────────────────────────────────────────
-function printAiPreview(summary, usage) {
-    console.log();
-    console.log(chalk.bold('AI-generated entry:'));
-    console.log(`  ${chalk.dim('Title:')}  ${summary.title}`);
-    console.log(`  ${chalk.dim('Type:')}   ${summary.entry_type}`);
-    console.log(chalk.dim('  Body:'));
-    for (const line of summary.body_markdown.split('\n')) {
-        console.log(`    ${line}`);
-    }
-    const limitLabel = usage.limit === null ? '∞' : String(usage.limit);
-    console.log(chalk.dim(`  Usage:  ${usage.used}/${limitLabel} this month (${usage.month_key})`));
-    console.log();
-}
-async function confirm(question) {
-    const { createInterface } = await import('node:readline');
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    const answer = await new Promise((resolve) => {
-        rl.question(`${question} [y/N] `, resolve);
-    });
-    rl.close();
-    return /^y(es)?$/i.test(answer.trim());
-}
 function resolveProject(cliArg) {
     if (cliArg)
         return cliArg;
@@ -256,7 +615,24 @@ function resolveProject(cliArg) {
     console.error(chalk.dim('  project: my-app'));
     process.exit(1);
 }
-function handleError(err) {
+/** JSON mode: raw data on stdout, so output pipes into jq/scripts cleanly. */
+function printJson(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+/** JSON mode errors go to stderr in the API's own error envelope shape. */
+function printJsonError(code, message) {
+    console.error(JSON.stringify({ error: { code, message } }));
+}
+function handleError(err, json) {
+    if (json) {
+        if (err instanceof ApiError) {
+            printJsonError(err.code, err.message);
+        }
+        else {
+            printJsonError('ERROR', err instanceof Error ? err.message : 'An unknown error occurred');
+        }
+        process.exit(1);
+    }
     if (err instanceof ApiError) {
         console.error(chalk.red(`Error: ${err.message}`));
         if (err.status === 401) {