deploylog 0.3.0 → 0.4.0

package/dist/init.d.ts

@@ -0,0 +1,38 @@
+import { type Project } from './api.js';
+export interface InitOptions {
+    project?: string;
+    type?: string;
+    force?: boolean;
+}
+export type InitResult = {
+    kind: 'written';
+    path: string;
+    project: string;
+    defaultType?: string;
+} | {
+    kind: 'exists';
+    message: string;
+} | {
+    kind: 'cancelled';
+    message: string;
+} | {
+    kind: 'missing-fields';
+    message: string;
+};
+export interface InitDeps {
+    api: {
+        listProjects(): Promise<Project[]>;
+    };
+    exists(path: string): boolean;
+    write(path: string, content: string): void;
+    /** Numbered pick from a list; resolves null when the user bails. */
+    select(question: string, choices: string[]): Promise<string | null>;
+    isTTY: boolean;
+    cwd(): string;
+}
+/**
+ * Scaffold .deploylog.yml in the current directory. Keys must match what
+ * readProjectConfig() consumes: `project` and `default_type`.
+ */
+export declare function runInit(opts: InitOptions, deps?: InitDeps): Promise<InitResult>;
+export declare const defaultInitDeps: InitDeps;

package/dist/init.js

@@ -0,0 +1,86 @@
+import { existsSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { listProjects } from './api.js';
+const ENTRY_TYPES = ['feature', 'fix', 'improvement', 'breaking', 'announcement'];
+/**
+ * Scaffold .deploylog.yml in the current directory. Keys must match what
+ * readProjectConfig() consumes: `project` and `default_type`.
+ */
+export async function runInit(opts, deps = defaultInitDeps) {
+    const path = join(deps.cwd(), '.deploylog.yml');
+    if (deps.exists(path) && !opts.force) {
+        return {
+            kind: 'exists',
+            message: `${path} already exists. Pass --force to overwrite it.`,
+        };
+    }
+    if (opts.type !== undefined && !ENTRY_TYPES.includes(opts.type)) {
+        return {
+            kind: 'missing-fields',
+            message: `Unknown default type '${opts.type}'. One of: ${ENTRY_TYPES.join(', ')}.`,
+        };
+    }
+    const projects = await deps.api.listProjects();
+    if (projects.length === 0) {
+        return {
+            kind: 'missing-fields',
+            message: 'No projects in your organization yet. Create one first: deploylog projects create <name>',
+        };
+    }
+    let projectSlug = opts.project;
+    if (projectSlug !== undefined) {
+        if (!projects.some((p) => p.slug === projectSlug)) {
+            return {
+                kind: 'missing-fields',
+                message: `Project '${projectSlug}' not found in your organization.\n` +
+                    `Available: ${projects.map((p) => p.slug).join(', ')}`,
+            };
+        }
+    }
+    else if (projects.length === 1) {
+        projectSlug = projects[0].slug;
+    }
+    else {
+        if (!deps.isTTY) {
+            return {
+                kind: 'missing-fields',
+                message: 'Multiple projects found. Pass --project <slug> in non-interactive mode.',
+            };
+        }
+        const picked = await deps.select('Which project should this directory push to?', projects.map((p) => `${p.slug}  (${p.name})`));
+        if (picked === null) {
+            return { kind: 'cancelled', message: 'Cancelled. No config written.' };
+        }
+        projectSlug = picked.split('  ')[0];
+    }
+    const lines = [`project: ${projectSlug}`];
+    if (opts.type)
+        lines.push(`default_type: ${opts.type}`);
+    deps.write(path, lines.join('\n') + '\n');
+    const result = { kind: 'written', path, project: projectSlug };
+    if (opts.type)
+        return { ...result, defaultType: opts.type };
+    return result;
+}
+async function selectPrompt(question, choices) {
+    const { createInterface } = await import('node:readline');
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    console.log(question);
+    choices.forEach((c, i) => console.log(`  ${i + 1}) ${c}`));
+    const answer = await new Promise((resolve) => {
+        rl.question(`Choose [1-${choices.length}]: `, resolve);
+    });
+    rl.close();
+    const idx = parseInt(answer.trim(), 10);
+    if (!Number.isInteger(idx) || idx < 1 || idx > choices.length)
+        return null;
+    return choices[idx - 1] ?? null;
+}
+export const defaultInitDeps = {
+    api: { listProjects },
+    exists: existsSync,
+    write: (path, content) => writeFileSync(path, content, 'utf8'),
+    select: selectPrompt,
+    isTTY: Boolean(process.stdin.isTTY),
+    cwd: () => process.cwd(),
+};

package/dist/open.d.ts

@@ -0,0 +1,33 @@
+import { type EntryDetail } from './api.js';
+import { type ProjectConfig } from './project-config.js';
+export interface OpenOptions {
+    ref?: string;
+    project?: string;
+}
+export type OpenResult = {
+    kind: 'opened';
+    url: string;
+} | {
+    kind: 'printed';
+    url: string;
+} | {
+    kind: 'missing-fields';
+    message: string;
+};
+export interface OpenDeps {
+    api: {
+        getEntry(id: string): Promise<EntryDetail>;
+    };
+    readProjectConfig(): ProjectConfig | null;
+    /** Try to open the URL in a browser; false when there's nothing to open with. */
+    launch(url: string): boolean;
+    baseUrl(): string;
+}
+/**
+ * Build the public URL (changelog page, or a single entry's page) and open it.
+ * A slug ref goes straight into the URL — public pages don't need auth. Only a
+ * uuid ref costs an API call (to look up the slug the public URL wants).
+ * Headless environments get the URL printed instead of a hung browser spawn.
+ */
+export declare function runOpen(opts: OpenOptions, deps?: OpenDeps): Promise<OpenResult>;
+export declare const defaultOpenDeps: OpenDeps;

package/dist/open.js

@@ -0,0 +1,51 @@
+import { spawn } from 'node:child_process';
+import { getEntry } from './api.js';
+import { getApiUrl } from './config.js';
+import { readProjectConfig } from './project-config.js';
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * Build the public URL (changelog page, or a single entry's page) and open it.
+ * A slug ref goes straight into the URL — public pages don't need auth. Only a
+ * uuid ref costs an API call (to look up the slug the public URL wants).
+ * Headless environments get the URL printed instead of a hung browser spawn.
+ */
+export async function runOpen(opts, deps = defaultOpenDeps) {
+    const projectConfig = deps.readProjectConfig();
+    const project = opts.project ?? projectConfig?.project;
+    if (!project) {
+        return {
+            kind: 'missing-fields',
+            message: 'No project specified. Use --project <slug> or create a .deploylog.yml with:\n  project: my-app',
+        };
+    }
+    const base = deps.baseUrl();
+    let url = `${base}/p/${project}/changelog`;
+    if (opts.ref) {
+        const entrySlug = UUID_RE.test(opts.ref)
+            ? (await deps.api.getEntry(opts.ref)).slug
+            : opts.ref;
+        url = `${base}/p/${project}/c/${entrySlug}`;
+    }
+    if (deps.launch(url)) {
+        return { kind: 'opened', url };
+    }
+    return { kind: 'printed', url };
+}
+function launchBrowser(url) {
+    // No display server → nothing to open with; the caller prints the URL.
+    if (process.platform === 'linux' && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) {
+        return false;
+    }
+    const opener = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+    const child = spawn(opener, [url], { stdio: 'ignore', detached: true });
+    // ENOENT arrives async — swallow it; the URL is printed either way.
+    child.on('error', () => { });
+    child.unref();
+    return true;
+}
+export const defaultOpenDeps = {
+    api: { getEntry },
+    readProjectConfig: () => readProjectConfig(),
+    launch: launchBrowser,
+    baseUrl: () => getApiUrl(),
+};

package/dist/project-config.d.ts

@@ -1,10 +1,20 @@
-interface ProjectConfig {
+export interface ProjectConfig {
     project?: string;
     default_type?: string;
 }
+export declare class ProjectConfigError extends Error {
+    constructor(message: string);
+}
 /**
- * Read .deploylog.yml from the current directory (or parents).
- * Returns null if not found.
+ * Read .deploylog.yml from `startDir` (or its parents).
+ *
+ * The walk distinguishes two failures the old code conflated:
+ *   - not found at this level  → keep walking up (returns null if none found)
+ *   - present but malformed    → STOP and throw, so a broken config never
+ *     silently falls through to a parent directory's config (a wrong-project
+ *     push) or a misleading "No project specified". (A3)
+ *
+ * `startDir` is injected (not read from `process.cwd()` here) so the walk is
+ * testable without `chdir`.
  */
-export declare function readProjectConfig(): ProjectConfig | null;
-export {};
+export declare function readProjectConfig(startDir?: string): ProjectConfig | null;

package/dist/project-config.js

@@ -1,20 +1,56 @@
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { parse } from 'yaml';
+export class ProjectConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ProjectConfigError';
+    }
+}
 /**
- * Read .deploylog.yml from the current directory (or parents).
- * Returns null if not found.
+ * Read .deploylog.yml from `startDir` (or its parents).
+ *
+ * The walk distinguishes two failures the old code conflated:
+ *   - not found at this level  → keep walking up (returns null if none found)
+ *   - present but malformed    → STOP and throw, so a broken config never
+ *     silently falls through to a parent directory's config (a wrong-project
+ *     push) or a misleading "No project specified". (A3)
+ *
+ * `startDir` is injected (not read from `process.cwd()` here) so the walk is
+ * testable without `chdir`.
  */
-export function readProjectConfig() {
-    let dir = process.cwd();
+export function readProjectConfig(startDir = process.cwd()) {
+    let dir = startDir;
     while (true) {
         const filePath = resolve(dir, '.deploylog.yml');
+        let content = null;
         try {
-            const content = readFileSync(filePath, 'utf-8');
-            return parse(content);
+            content = readFileSync(filePath, 'utf-8');
         }
         catch {
-            // File not found, try parent
+            // Not found (or unreadable) at this level — walk up.
+            content = null;
+        }
+        if (content !== null) {
+            // A file exists here: this level is authoritative. Any parse/shape
+            // failure stops the walk — we never adopt a parent's config behind a
+            // broken file.
+            let parsed;
+            try {
+                parsed = parse(content);
+            }
+            catch (err) {
+                const detail = err instanceof Error ? err.message : String(err);
+                throw new ProjectConfigError(`Invalid YAML in ${filePath}: ${detail}`);
+            }
+            // An empty file parses to null/undefined — treat as a present-but-empty
+            // config (stops the walk), not "not found".
+            if (parsed === null || parsed === undefined)
+                return {};
+            if (typeof parsed !== 'object' || Array.isArray(parsed)) {
+                throw new ProjectConfigError(`Invalid .deploylog.yml at ${filePath}: expected a mapping like "project: my-app".`);
+            }
+            return parsed;
         }
         const parent = resolve(dir, '..');
         if (parent === dir)

package/dist/push.d.ts

@@ -0,0 +1,71 @@
+import { type CommitSummary } from './git.js';
+import { type Entry, type CreateEntryInput, type SummarizeInput, type SummarizeResponse, type AiSummary } from './api.js';
+import { type ProjectConfig } from './project-config.js';
+/** Raw commander options for `push`, aliases included (reconciled inside runPush). */
+export interface PushOptions {
+    title?: string;
+    body?: string;
+    project?: string;
+    type?: string;
+    version?: string;
+    publish?: boolean;
+    draft?: boolean;
+    fromGit?: boolean;
+    git?: boolean;
+    aiSummarize?: boolean;
+    ai?: boolean;
+    yes?: boolean;
+}
+/**
+ * Outcome of a push attempt. `created` carries the entry; every other kind is a
+ * typed refusal that replaces a `process.exit(1)` — the adapter decides how to
+ * print and what exit code to use.
+ */
+export type PushResult = {
+    kind: 'created';
+    entry: Entry;
+} | {
+    kind: 'no-commits';
+    message: string;
+} | {
+    kind: 'no-ai-source';
+    message: string;
+} | {
+    kind: 'missing-fields';
+    message: string;
+} | {
+    kind: 'cancelled';
+    message: string;
+};
+/** Presentational sink — the progress/preview/warning lines runPush emits mid-flow. */
+export interface PushOutput {
+    progressStart(msg: string): void;
+    progressDone(msg: string): void;
+    notice(msg: string): void;
+    aiPreview(summary: AiSummary, usage: SummarizeResponse['usage']): void;
+}
+export interface PushDeps {
+    git: {
+        isGitRepo(): boolean;
+        getLastTag(): string | null;
+        getHeadVersion(): string | null;
+        getCommitsSince(ref: string | null): CommitSummary[];
+        defaultTitleFromGit(version: string | null, lastTag: string | null): string;
+        formatCommitsAsMarkdown(commits: CommitSummary[]): string;
+    };
+    api: {
+        createEntry(slug: string, input: CreateEntryInput): Promise<Entry>;
+        summarize(input: SummarizeInput): Promise<SummarizeResponse>;
+    };
+    readProjectConfig(): ProjectConfig | null;
+    confirm(question: string): Promise<boolean>;
+    isTTY: boolean;
+    out: PushOutput;
+}
+/**
+ * The push orchestration as a pure(ish) function: takes options + injected
+ * boundaries, returns a typed result. No `process.exit`, no direct git/network
+ * — every branch is reachable from a unit test.
+ */
+export declare function runPush(opts: PushOptions, deps?: PushDeps): Promise<PushResult>;
+export declare const defaultPushDeps: PushDeps;

package/dist/push.js

@@ -0,0 +1,149 @@
+import chalk from 'chalk';
+import { isGitRepo, getLastTag, getHeadVersion, getCommitsSince, defaultTitleFromGit, formatCommitsAsMarkdown, } from './git.js';
+import { createEntry, summarize, } from './api.js';
+import { readProjectConfig } from './project-config.js';
+/**
+ * The push orchestration as a pure(ish) function: takes options + injected
+ * boundaries, returns a typed result. No `process.exit`, no direct git/network
+ * — every branch is reachable from a unit test.
+ */
+export async function runPush(opts, deps = defaultPushDeps) {
+    const { git, api, out } = deps;
+    // Reconcile each flag with its alias (-g/--git, -a/--ai).
+    const fromGit = Boolean(opts.fromGit || opts.git);
+    const aiSummarize = Boolean(opts.aiSummarize || opts.ai);
+    // Resolve the project (flag > .deploylog.yml). Missing is a refusal, not an exit.
+    const projectConfig = deps.readProjectConfig();
+    const slug = opts.project ?? projectConfig?.project;
+    if (!slug) {
+        return {
+            kind: 'missing-fields',
+            message: 'No project specified. Use --project <slug> or create a .deploylog.yml with:\n  project: my-app',
+        };
+    }
+    // Gather source material (commits + version) if --from-git. This precedes the
+    // AI-source check so --ai-summarize can see the commits.
+    let commits = [];
+    let gitVersion = null;
+    let gitTitle = null;
+    let gitBody = null;
+    if (fromGit) {
+        if (!git.isGitRepo()) {
+            return {
+                kind: 'no-commits',
+                message: 'Not in a git repository. Remove --from-git or cd to a repo.',
+            };
+        }
+        const lastTag = git.getLastTag();
+        commits = git.getCommitsSince(lastTag);
+        gitVersion = git.getHeadVersion();
+        gitTitle = git.defaultTitleFromGit(gitVersion, lastTag);
+        gitBody = git.formatCommitsAsMarkdown(commits);
+        if (commits.length === 0 && !opts.body && !aiSummarize) {
+            return {
+                kind: 'no-commits',
+                message: lastTag
+                    ? `No commits since tag ${lastTag}. Nothing to summarize.`
+                    : 'No commits found on HEAD.',
+            };
+        }
+    }
+    // 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 (aiSummarize) {
+        const hasSource = commits.length > 0 || Boolean(opts.body && opts.body.trim().length > 0);
+        if (!hasSource) {
+            return {
+                kind: 'no-ai-source',
+                message: '--ai-summarize needs source material. Pass --from-git or provide --body as raw notes.',
+            };
+        }
+        out.progressStart('Summarizing with Claude Haiku...');
+        const res = await api.summarize({
+            project_slug: slug,
+            commits: commits.map((c) => c.subject),
+            release_notes: opts.body,
+            version,
+        });
+        out.progressDone('done');
+        // AI result overrides the body but never an explicit --title.
+        title = opts.title ?? res.summary.title;
+        body = res.summary.body_markdown;
+        entryType = opts.type ?? res.summary.entry_type;
+        out.aiPreview(res.summary, res.usage);
+        if (!opts.yes && deps.isTTY) {
+            const ok = await deps.confirm('Publish this entry?');
+            if (!ok) {
+                return { kind: 'cancelled', message: 'Cancelled. No entry was created.' };
+            }
+        }
+        else if (!opts.yes) {
+            // Non-interactive shell (CI, piped stdin): no prompt to show, so make the
+            // unreviewed auto-proceed explicit. (BUG-019)
+            out.notice('Non-interactive shell: proceeding with the AI-generated entry without confirmation.');
+        }
+    }
+    if (!title || !body) {
+        return {
+            kind: 'missing-fields',
+            message: 'Entry requires --title and --body (or --from-git / --ai-summarize to derive them).',
+        };
+    }
+    if (opts.publish && opts.draft) {
+        out.notice('Both --publish and --draft passed; saving as a draft.');
+    }
+    const entry = await api.createEntry(slug, {
+        title,
+        body_markdown: body,
+        entry_type: entryType,
+        version,
+        publish: Boolean(opts.publish && !opts.draft),
+    });
+    return { kind: 'created', entry };
+}
+// ─── real-module defaults ─────────────────────────────────────────────────────
+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 confirmPrompt(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());
+}
+export const defaultPushDeps = {
+    git: {
+        isGitRepo: () => isGitRepo(),
+        getLastTag: () => getLastTag(),
+        getHeadVersion: () => getHeadVersion(),
+        getCommitsSince: (ref) => getCommitsSince(ref),
+        defaultTitleFromGit,
+        formatCommitsAsMarkdown,
+    },
+    api: { createEntry, summarize },
+    readProjectConfig: () => readProjectConfig(),
+    confirm: confirmPrompt,
+    isTTY: Boolean(process.stdin.isTTY),
+    out: {
+        progressStart: (msg) => process.stdout.write(chalk.dim(`${msg} `)),
+        progressDone: (msg) => process.stdout.write(chalk.green(`${msg}\n`)),
+        notice: (msg) => console.log(chalk.yellow(msg)),
+        aiPreview: printAiPreview,
+    },
+};

package/dist/resolve.d.ts

@@ -0,0 +1,18 @@
+import type { Entry } from './api.js';
+/**
+ * Resolve a user-supplied entry reference (slug or id) to an entry id.
+ *
+ * The id is the canonical handle — slugs are mutable on drafts (a title edit
+ * regenerates them), so a uuid-shaped ref is passed straight through and the
+ * server's org-scoped lookup is the authority. A slug is matched against the
+ * project's recent entries; entries beyond that window need the id.
+ */
+export type ResolveResult = {
+    kind: 'resolved';
+    id: string;
+    entry?: Entry;
+} | {
+    kind: 'not-found';
+    message: string;
+};
+export declare function resolveEntryRef(ref: string, projectSlug: string, listEntries: (slug: string) => Promise<Entry[]>): Promise<ResolveResult>;

package/dist/resolve.js

@@ -0,0 +1,16 @@
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export async function resolveEntryRef(ref, projectSlug, listEntries) {
+    if (UUID_RE.test(ref)) {
+        return { kind: 'resolved', id: ref };
+    }
+    const entries = await listEntries(projectSlug);
+    const match = entries.find((e) => e.slug === ref);
+    if (match) {
+        return { kind: 'resolved', id: match.id, entry: match };
+    }
+    return {
+        kind: 'not-found',
+        message: `Entry '${ref}' not found in the ${entries.length} most recent entries of '${projectSlug}'.\n` +
+            'Older entries must be referenced by id — `deploylog list` shows ids.',
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deploylog",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Push changelog entries from the terminal",
   "type": "module",
   "bin": {