deploylog 0.1.0 → 0.2.0

package/dist/api.d.ts

@@ -30,3 +30,25 @@ export interface CreateEntryInput {
     publish?: boolean;
 }
 export declare function createEntry(projectSlug: string, input: CreateEntryInput): Promise<Entry>;
+export interface SummarizeInput {
+    project_slug?: string;
+    commits?: string[];
+    release_notes?: string;
+    version?: string;
+}
+export type EntryType = 'feature' | 'fix' | 'improvement' | 'breaking' | 'announcement';
+export interface AiSummary {
+    title: string;
+    entry_type: EntryType;
+    body_markdown: string;
+}
+export interface SummarizeResponse {
+    summary: AiSummary;
+    model: string;
+    usage: {
+        used: number;
+        limit: number | null;
+        month_key: string;
+    };
+}
+export declare function summarize(input: SummarizeInput): Promise<SummarizeResponse>;

package/dist/api.js

@@ -41,3 +41,9 @@ export async function createEntry(projectSlug, input) {
         body: JSON.stringify(input),
     });
 }
+export async function summarize(input) {
+    return request('/ai-summarize', {
+        method: 'POST',
+        body: JSON.stringify(input),
+    });
+}

package/dist/git.d.ts

@@ -0,0 +1,38 @@
+export declare class GitError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thin shell-out wrapper. Exported for test injection.
+ * Returns stdout with trailing newline trimmed, or null on non-zero exit.
+ */
+export declare function runGit(args: string[], cwd?: string): string | null;
+export interface GitRunner {
+    (args: string[]): string | null;
+}
+export declare function isGitRepo(run?: GitRunner): boolean;
+/**
+ * Most recent annotated or lightweight tag reachable from HEAD, or null.
+ */
+export declare function getLastTag(run?: GitRunner): string | null;
+/**
+ * If HEAD is on a tag that looks like semver (v1.2.3 or 1.2.3), return the
+ * bare semver string (without the 'v'). Otherwise null.
+ */
+export declare function getHeadVersion(run?: GitRunner): string | null;
+export interface CommitSummary {
+    hash: string;
+    subject: string;
+}
+/**
+ * Commit subjects (and short hashes) between `ref` and HEAD, oldest-first.
+ * If `ref` is null, returns the most recent `limit` commits on HEAD.
+ */
+export declare function getCommitsSince(ref: string | null, limit?: number, run?: GitRunner): CommitSummary[];
+/**
+ * Derive a sensible default title from the latest tag (or fallback).
+ */
+export declare function defaultTitleFromGit(version: string | null, lastTag: string | null): string;
+/**
+ * Format a commit list as a markdown bullet body.
+ */
+export declare function formatCommitsAsMarkdown(commits: CommitSummary[]): string;

package/dist/git.js

@@ -0,0 +1,92 @@
+import { execFileSync } from 'node:child_process';
+export class GitError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'GitError';
+    }
+}
+/**
+ * Thin shell-out wrapper. Exported for test injection.
+ * Returns stdout with trailing newline trimmed, or null on non-zero exit.
+ */
+export function runGit(args, cwd = process.cwd()) {
+    try {
+        return execFileSync('git', args, {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
+        }).replace(/\n$/, '');
+    }
+    catch {
+        return null;
+    }
+}
+export function isGitRepo(run = runGit) {
+    return run(['rev-parse', '--is-inside-work-tree']) === 'true';
+}
+/**
+ * Most recent annotated or lightweight tag reachable from HEAD, or null.
+ */
+export function getLastTag(run = runGit) {
+    const out = run(['describe', '--tags', '--abbrev=0']);
+    return out && out.length > 0 ? out : null;
+}
+/**
+ * If HEAD is on a tag that looks like semver (v1.2.3 or 1.2.3), return the
+ * bare semver string (without the 'v'). Otherwise null.
+ */
+export function getHeadVersion(run = runGit) {
+    const exact = run(['tag', '--points-at', 'HEAD']);
+    if (!exact)
+        return null;
+    for (const line of exact.split('\n')) {
+        const m = line.match(/^v?(\d+\.\d+\.\d+)$/);
+        if (m?.[1])
+            return m[1];
+    }
+    return null;
+}
+/**
+ * Commit subjects (and short hashes) between `ref` and HEAD, oldest-first.
+ * If `ref` is null, returns the most recent `limit` commits on HEAD.
+ */
+export function getCommitsSince(ref, limit = 200, run = runGit) {
+    const range = ref ? `${ref}..HEAD` : 'HEAD';
+    const args = ['log', range, `--pretty=format:%h\t%s`, '--no-merges', `-${limit}`, '--reverse'];
+    const out = run(args);
+    if (out === null) {
+        // `ref..HEAD` with an unknown ref (or an empty repo) returns null via our wrapper.
+        return [];
+    }
+    if (out.length === 0)
+        return [];
+    const commits = [];
+    for (const line of out.split('\n')) {
+        const tab = line.indexOf('\t');
+        if (tab < 0)
+            continue;
+        const hash = line.slice(0, tab);
+        const subject = line.slice(tab + 1).trim();
+        if (subject.length > 0)
+            commits.push({ hash, subject });
+    }
+    return commits;
+}
+/**
+ * Derive a sensible default title from the latest tag (or fallback).
+ */
+export function defaultTitleFromGit(version, lastTag) {
+    if (version)
+        return `Release v${version}`;
+    if (lastTag)
+        return `Changes since ${lastTag}`;
+    return 'Recent changes';
+}
+/**
+ * Format a commit list as a markdown bullet body.
+ */
+export function formatCommitsAsMarkdown(commits) {
+    if (commits.length === 0)
+        return '_No new commits since last tag._';
+    return commits.map((c) => `- ${c.subject}`).join('\n');
+}

package/dist/index.js

@@ -2,13 +2,14 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { setApiKey, setApiUrl, getConfigPath, clearConfig } from './config.js';
-import { listProjects, listEntries, createEntry, ApiError } from './api.js';
+import { listProjects, listEntries, createEntry, summarize, ApiError, } from './api.js';
 import { readProjectConfig } from './project-config.js';
+import { isGitRepo, getLastTag, getHeadVersion, getCommitsSince, defaultTitleFromGit, formatCommitsAsMarkdown, } from './git.js';
 const program = new Command();
 program
     .name('deploylog')
     .description('Push changelog entries from the terminal')
-    .version('0.1.0');
+    .version('0.2.0');
 // ─── login ──────────────────────────────────────────────────────────────────
 program
     .command('login')
@@ -108,22 +109,82 @@ program
 program
     .command('push')
     .description('Create a new changelog entry')
-    .requiredOption('-t, --title <title>', 'Entry title')
-    .requiredOption('-b, --body <markdown>', 'Entry body (Markdown)')
+    .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('--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('-y, --yes', 'Skip interactive confirmation for AI-generated content')
     .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);
+            }
+            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.'));
+                process.exit(1);
+            }
+        }
+        // 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.'));
+                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;
+                }
+            }
+        }
+        if (!title || !body) {
+            console.error(chalk.red('Entry requires --title and --body (or --from-git / --ai-summarize to derive them).'));
+            process.exit(1);
+        }
         const entry = await createEntry(slug, {
-            title: opts.title,
-            body_markdown: opts.body,
-            entry_type: opts.type ?? projectConfig?.default_type ?? null,
-            version: opts.version,
+            title,
+            body_markdown: body,
+            entry_type: entryType,
+            version,
             publish: opts.publish && !opts.draft,
         });
         const status = entry.published
@@ -140,6 +201,28 @@ program
     }
 });
 // ─── 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;

package/package.json

@@ -1,19 +1,29 @@
 {
   "name": "deploylog",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Push changelog entries from the terminal",
   "type": "module",
   "bin": {
     "deploylog": "./dist/index.js"
   },
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
     "prepublishOnly": "tsc",
-    "start": "node dist/index.js"
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
-  "keywords": ["changelog", "deploylog", "cli", "release-notes", "devtools"],
+  "keywords": [
+    "changelog",
+    "deploylog",
+    "cli",
+    "release-notes",
+    "devtools"
+  ],
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -28,6 +38,7 @@
   },
   "devDependencies": {
     "@types/node": "^22.15.3",
-    "typescript": "^5.8.3"
+    "typescript": "^5.8.3",
+    "vitest": "^4.1.4"
   }
 }