@releasekit/notes 0.1.0 → 0.1.1-next.0

package/README.md

@@ -1,175 +1,113 @@
-# changelog-creator
+# @releasekit/notes
 
-A CLI tool for generating changelogs with LLM-powered enhancement and flexible templating.
+Changelog generation with LLM-powered enhancement and flexible templating.
 
 ## Features
 
-- **Multiple input sources**: package-versioner JSON, git log, manual JSON
-- **Flexible templating**: Liquid, Handlebars, EJS - single file or composable
-- **LLM enhancement** (optional): Summarize, categorize, enhance descriptions, generate release notes
-- **Monorepo support**: Root aggregation, per-package changelogs, or both
-- **Multiple outputs**: Markdown, JSON, GitHub Releases API
+- **Multiple input sources** — `@releasekit/version` JSON, git log, or manual JSON
+- **Flexible templating** — Liquid, Handlebars, or EJS with single-file or composable templates
+- **LLM enhancement** (optional) — summarize, categorize, enhance descriptions, generate release notes
+- **Monorepo support** — root aggregation, per-package changelogs, or both
+- **Multiple outputs** — Markdown, JSON, or GitHub Releases API
+- **Dry-run mode** — preview without writing files
 
 ## Installation
 
 ```bash
-npm install -g changelog-creator
+npm install -g @releasekit/notes
 # or
-pnpm add -g changelog-creator
+pnpm add -g @releasekit/notes
 ```
 
 ## Quick Start
 
 ```bash
-# Pipe from package-versioner
-npx package-versioner --json | changelog-creator
+# Pipe from @releasekit/version
+releasekit-version --json | releasekit-notes
 
-# From file
-changelog-creator --input version-data.json
+# From a file
+releasekit-notes --input version-data.json
 
 # With LLM enhancement
-changelog-creator --input version-data.json --llm-provider openai --llm-model gpt-4o-mini
-```
+releasekit-notes --input version-data.json --llm-provider openai --llm-model gpt-4o-mini
 
-## CLI Commands
+# Preview without writing
+releasekit-notes --dry-run
+```
 
-### `changelog-creator generate` (default)
+## CLI Reference
 
-Generate changelog from input data.
+| Flag | Description | Default |
+|------|-------------|---------|
+| `-i, --input <file>` | Input file path | stdin |
+| `-o, --output <spec>` | Output spec (`format:file`) | config |
+| `-t, --template <path>` | Template file or directory | built-in |
+| `-e, --engine <engine>` | Template engine: `handlebars`, `liquid`, `ejs` | `liquid` |
+| `--monorepo <mode>` | Monorepo mode: `root`, `packages`, `both` | — |
+| `--llm-provider <name>` | LLM provider | — |
+| `--llm-model <model>` | LLM model | — |
+| `--llm-tasks <tasks>` | Comma-separated LLM tasks | — |
+| `--no-llm` | Disable LLM processing | `false` |
+| `--config <path>` | Config file path | `releasekit.config.json` |
+| `--dry-run` | Preview without writing | `false` |
+| `--regenerate` | Regenerate entire changelog | `false` |
+| `-v, --verbose` | Verbose logging | `false` |
+| `-q, --quiet` | Suppress non-error output | `false` |
 
-```bash
-changelog-creator [options]
-
-Options:
-  -i, --input <file>          Input file (default: stdin)
-  -o, --output <spec>         Output spec (format:file)
-  -t, --template <path>       Template file or directory
-  -e, --engine <engine>       Template engine (handlebars|liquid|ejs)
-  --monorepo <mode>           Monorepo mode (root|packages|both)
-  --llm-provider <provider>   LLM provider
-  --llm-model <model>         LLM model
-  --llm-tasks <tasks>         Comma-separated LLM tasks
-  --no-llm                    Disable LLM processing
-  --config <path>             Config file path
-  --dry-run                   Preview without writing
-  --regenerate                Regenerate entire changelog
-  -v, --verbose               Increase verbosity
-  -q, --quiet                 Suppress non-error output
-```
+## Subcommands
 
-### `changelog-creator init`
+### `releasekit-notes init`
 
 Create a default configuration file.
 
 ```bash
-changelog-creator init [--force]
+releasekit-notes init [--force]
 ```
 
-### `changelog-creator auth <provider>`
+### `releasekit-notes auth <provider>`
 
 Configure API key for an LLM provider.
 
 ```bash
-changelog-creator auth openai --key sk-...
-changelog-creator auth anthropic
+releasekit-notes auth openai --key sk-...
+releasekit-notes auth anthropic
 ```
 
-### `changelog-creator providers`
+### `releasekit-notes providers`
 
 List available LLM providers.
 
 ## Configuration
 
-Create `changelog.config.json` in your project root:
+Configure via `releasekit.config.json`:
 
 ```json
 {
-  "output": [
-    { "format": "markdown", "file": "CHANGELOG.md" }
-  ],
-  "updateStrategy": "prepend",
-  "templates": {
-    "path": "./templates/",
-    "engine": "liquid"
-  },
-  "llm": {
-    "provider": "openai",
-    "model": "gpt-4o-mini",
-    "tasks": {
-      "summarize": true,
-      "enhance": true
+  "notes": {
+    "output": [
+      { "format": "markdown", "file": "CHANGELOG.md" }
+    ],
+    "updateStrategy": "prepend",
+    "templates": {
+      "path": "./templates/",
+      "engine": "liquid"
+    },
+    "llm": {
+      "provider": "openai",
+      "model": "gpt-4o-mini",
+      "tasks": {
+        "summarize": true,
+        "enhance": true
+      }
     }
   }
 }
 ```
 
-### Config Locations (precedence)
-
-1. `CHANGELOG_CONFIG_CONTENT` env var
-2. `--config` CLI flag
-3. `changelog.config.json` in project
-4. `~/.config/changelog-creator/config.json`
-
-## Input Sources
-
-### package-versioner JSON
-
-```bash
-npx package-versioner --json | changelog-creator
-```
-
-### Git Log
-
-```bash
-changelog-creator --input-source git-log --from v1.0.0 --to HEAD
-```
-
-### Manual JSON
-
-```json
-{
-  "packages": [{
-    "packageName": "my-app",
-    "version": "1.2.0",
-    "entries": [
-      { "type": "added", "description": "New feature" }
-    ]
-  }]
-}
-```
-
-## Templates
-
-### Single File
-
-```bash
-changelog-creator --template ./my-changelog.liquid
-```
-
-### Composable
-
-```bash
-changelog-creator --template ./templates/
-```
-
-Directory structure:
-```
-templates/
-├── document.liquid
-├── version.liquid
-└── entry.liquid
-```
-
-### Built-in Templates
-
-- `keep-a-changelog` - Default, Keep a Changelog format
-- `angular` - Angular-style changelog
-- `github-release` - GitHub release notes
-
 ## LLM Providers
 
-| Provider | Config | Notes |
-|----------|--------|-------|
+| Provider | Config Key | Notes |
+|----------|------------|-------|
 | OpenAI | `openai` | Requires `OPENAI_API_KEY` |
 | Anthropic | `anthropic` | Requires `ANTHROPIC_API_KEY` |
 | Ollama | `ollama` | Local, no API key needed |
@@ -184,38 +122,44 @@ templates/
 | `categorize` | Group entries by category |
 | `releaseNotes` | Generate release notes |
 
-## Monorepo Support
+## Templates
 
-```bash
-# Root changelog only (aggregates all packages)
-changelog-creator --monorepo root
+### Built-in
 
-# Per-package changelogs
-changelog-creator --monorepo packages
+- `keep-a-changelog` — Keep a Changelog format (default)
+- `angular` — Angular-style changelog
+- `github-release` — GitHub release notes
 
-# Both
-changelog-creator --monorepo both
-```
-
-## Output Formats
-
-### Markdown
+### Custom Templates
 
 ```bash
-changelog-creator -o markdown:CHANGELOG.md
+# Single file
+releasekit-notes --template ./my-changelog.liquid
+
+# Composable directory
+releasekit-notes --template ./templates/
 ```
 
-### JSON
+Composable directory structure:
 
-```bash
-changelog-creator -o json:changelog.json
+```
+templates/
+├── document.liquid
+├── version.liquid
+└── entry.liquid
 ```
 
-### GitHub Release
+## Monorepo Support
 
 ```bash
-changelog-creator -o github-release
-# Requires GITHUB_TOKEN env var
+# Root changelog only (aggregates all packages)
+releasekit-notes --monorepo root
+
+# Per-package changelogs
+releasekit-notes --monorepo packages
+
+# Both
+releasekit-notes --monorepo both
 ```
 
 ## License

package/dist/{chunk-GN5RQW3G.js → chunk-W7DVGQ7D.js}

@@ -195,6 +195,10 @@ function formatVersion(context) {
     lines.push(`[Full Changelog](${context.compareUrl})`);
     lines.push("");
   }
+  if (context.enhanced?.summary) {
+    lines.push(context.enhanced.summary);
+    lines.push("");
+  }
   const grouped = groupEntriesByType(context.entries);
   for (const [type, entries] of grouped) {
     if (entries.length === 0) continue;
@@ -379,15 +383,17 @@ var OllamaProvider = class extends BaseLLMProvider {
   name = "ollama";
   baseURL;
   model;
+  apiKey;
   constructor(config = {}) {
     super();
     this.baseURL = config.baseURL ?? process.env.OLLAMA_BASE_URL ?? "http://localhost:11434";
     this.model = config.model ?? LLM_DEFAULTS.models.ollama;
+    this.apiKey = config.apiKey ?? process.env.OLLAMA_API_KEY;
   }
   async complete(prompt, options) {
     const requestBody = {
       model: this.model,
-      prompt,
+      messages: [{ role: "user", content: prompt }],
       stream: false,
       options: {
         num_predict: this.getMaxTokens(options),
@@ -395,11 +401,16 @@ var OllamaProvider = class extends BaseLLMProvider {
       }
     };
     try {
-      const response = await fetch(`${this.baseURL}/api/generate`, {
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (this.apiKey) {
+        headers["Authorization"] = `Bearer ${this.apiKey}`;
+      }
+      const baseUrl = this.baseURL.endsWith("/api") ? this.baseURL.slice(0, -4) : this.baseURL;
+      const response = await fetch(`${baseUrl}/api/chat`, {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
+        headers,
         body: JSON.stringify(requestBody)
       });
       if (!response.ok) {
@@ -407,10 +418,10 @@ var OllamaProvider = class extends BaseLLMProvider {
         throw new LLMError(`Ollama request failed: ${response.status} ${text}`);
       }
       const data = await response.json();
-      if (!data.response) {
+      if (!data.message?.content) {
         throw new LLMError("Empty response from Ollama");
       }
-      return data.response;
+      return data.message.content;
     } catch (error) {
       if (error instanceof LLMError) throw error;
       throw new LLMError(`Ollama error: ${error instanceof Error ? error.message : String(error)}`);
@@ -493,7 +504,7 @@ var OpenAICompatibleProvider = class extends BaseLLMProvider {
 
 // src/llm/tasks/categorize.ts
 import { warn } from "@releasekit/core";
-var CATEGORIZE_PROMPT = `You are categorizing changelog entries for a software release.
+var DEFAULT_CATEGORIZE_PROMPT = `You are categorizing changelog entries for a software release.
 
 Given the following entries, group them into meaningful categories (e.g., "Core", "UI", "API", "Performance", "Bug Fixes", "Documentation").
 
@@ -503,24 +514,63 @@ Entries:
 {{entries}}
 
 Output only valid JSON, nothing else:`;
-async function categorizeEntries(provider, entries, _context) {
+function buildCustomCategorizePrompt(categories) {
+  const categoryList = categories.map((c) => `- "${c.name}": ${c.description}`).join("\n");
+  return `You are categorizing changelog entries for a software release.
+
+Given the following entries, group them into the specified categories. Only use the categories listed below.
+
+Categories:
+${categoryList}
+
+For entries in categories that involve internal/developer changes, set a "scope" field on those entries with a short subcategory label (e.g., "CI", "Dependencies", "Testing", "Code Quality", "Build System").
+
+Output a JSON object with two fields:
+- "categories": an object where keys are category names and values are arrays of entry indices (0-based)
+- "scopes": an object where keys are entry indices (as strings) and values are scope labels
+
+Entries:
+{{entries}}
+
+Output only valid JSON, nothing else:`;
+}
+async function categorizeEntries(provider, entries, context) {
   if (entries.length === 0) {
     return [];
   }
   const entriesText = entries.map((e, i) => `${i}. [${e.type}]${e.scope ? ` (${e.scope})` : ""}: ${e.description}`).join("\n");
-  const prompt = CATEGORIZE_PROMPT.replace("{{entries}}", entriesText);
+  const hasCustomCategories = context.categories && context.categories.length > 0;
+  const promptTemplate = hasCustomCategories ? buildCustomCategorizePrompt(context.categories) : DEFAULT_CATEGORIZE_PROMPT;
+  const prompt = promptTemplate.replace("{{entries}}", entriesText);
   try {
     const response = await provider.complete(prompt);
     const cleaned = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
     const parsed = JSON.parse(cleaned);
     const result = [];
-    for (const [category, indices] of Object.entries(parsed)) {
-      const categoryEntries = indices.map((i) => entries[i]).filter((e) => e !== void 0);
-      if (categoryEntries.length > 0) {
-        result.push({
-          category,
-          entries: categoryEntries
-        });
+    if (hasCustomCategories && parsed.categories) {
+      const categoryMap = parsed.categories;
+      const scopeMap = parsed.scopes || {};
+      for (const [indexStr, scope] of Object.entries(scopeMap)) {
+        const idx = Number.parseInt(indexStr, 10);
+        if (entries[idx] && scope) {
+          entries[idx] = { ...entries[idx], scope };
+        }
+      }
+      for (const [category, rawIndices] of Object.entries(categoryMap)) {
+        const indices = Array.isArray(rawIndices) ? rawIndices : [];
+        const categoryEntries = indices.map((i) => entries[i]).filter((e) => e !== void 0);
+        if (categoryEntries.length > 0) {
+          result.push({ category, entries: categoryEntries });
+        }
+      }
+    } else {
+      const categoryMap = parsed;
+      for (const [category, rawIndices] of Object.entries(categoryMap)) {
+        const indices = Array.isArray(rawIndices) ? rawIndices : [];
+        const categoryEntries = indices.map((i) => entries[i]).filter((e) => e !== void 0);
+        if (categoryEntries.length > 0) {
+          result.push({ category, entries: categoryEntries });
+        }
       }
     }
     return result;
@@ -538,10 +588,10 @@ Given a technical commit message, rewrite it as a clear, user-friendly changelog
 
 Rules:
 - Be concise (1-2 sentences max)
-- Use present tense ("Add feature" not "Added feature")
 - Focus on user impact, not implementation details
 - Don't use technical jargon unless necessary
 - Preserve the scope if mentioned (e.g., "core:", "api:")
+{{style}}
 
 Original entry:
 Type: {{type}}
@@ -550,7 +600,8 @@ Description: {{description}}
 
 Rewritten description (only output the new description, nothing else):`;
 async function enhanceEntry(provider, entry, _context) {
-  const prompt = ENHANCE_PROMPT.replace("{{type}}", entry.type).replace("{{#if scope}}Scope: {{scope}}{{/if}}", entry.scope ? `Scope: ${entry.scope}` : "").replace("{{description}}", entry.description);
+  const styleText = _context.style ? `- ${_context.style}` : '- Use present tense ("Add feature" not "Added feature")';
+  const prompt = ENHANCE_PROMPT.replace("{{style}}", styleText).replace("{{type}}", entry.type).replace("{{#if scope}}Scope: {{scope}}{{/if}}", entry.scope ? `Scope: ${entry.scope}` : "").replace("{{description}}", entry.description);
   const response = await provider.complete(prompt);
   return response.trim();
 }
@@ -652,6 +703,7 @@ function createProvider(config) {
       });
     case "ollama":
       return new OllamaProvider({
+        apiKey,
         baseURL: config.baseURL,
         model: config.model
       });
@@ -1111,37 +1163,58 @@ async function processWithLLM(context, config) {
     packageName: context.packageName,
     version: context.version,
     previousVersion: context.previousVersion ?? void 0,
-    date: context.date
+    date: context.date,
+    categories: config.llm.categories,
+    style: config.llm.style
   };
   const enhanced = {
     entries: context.entries
   };
   try {
+    info4(`Using LLM provider: ${config.llm.provider}${config.llm.model ? ` (${config.llm.model})` : ""}`);
+    if (config.llm.baseURL) {
+      info4(`LLM base URL: ${config.llm.baseURL}`);
+    }
     const rawProvider = createProvider(config.llm);
     const retryOpts = config.llm.retry ?? LLM_DEFAULTS.retry;
     const provider = {
       name: rawProvider.name,
       complete: (prompt, opts) => withRetry(() => rawProvider.complete(prompt, opts), retryOpts)
     };
+    const activeTasks = Object.entries(tasks).filter(([, enabled]) => enabled).map(([name]) => name);
+    info4(`Running LLM tasks: ${activeTasks.join(", ")}`);
     if (tasks.enhance) {
-      debug("Enhancing entries with LLM");
+      info4("Enhancing entries with LLM...");
       enhanced.entries = await enhanceEntries(provider, context.entries, llmContext, config.llm.concurrency);
+      info4(`Enhanced ${enhanced.entries.length} entries`);
     }
     if (tasks.summarize) {
-      debug("Summarizing entries with LLM");
+      info4("Summarizing entries with LLM...");
       enhanced.summary = await summarizeEntries(provider, enhanced.entries, llmContext);
+      if (enhanced.summary) {
+        info4("Summary generated successfully");
+        debug(`Summary: ${enhanced.summary.substring(0, 100)}...`);
+      } else {
+        warn2("Summary generation returned empty result");
+      }
     }
     if (tasks.categorize) {
-      debug("Categorizing entries with LLM");
+      info4("Categorizing entries with LLM...");
       const categorized = await categorizeEntries(provider, enhanced.entries, llmContext);
       enhanced.categories = {};
       for (const cat of categorized) {
         enhanced.categories[cat.category] = cat.entries;
       }
+      info4(`Created ${categorized.length} categories`);
     }
     if (tasks.releaseNotes) {
-      debug("Generating release notes with LLM");
+      info4("Generating release notes with LLM...");
       enhanced.releaseNotes = await generateReleaseNotes(provider, enhanced.entries, llmContext);
+      if (enhanced.releaseNotes) {
+        info4("Release notes generated successfully");
+      } else {
+        warn2("Release notes generation returned empty result");
+      }
     }
     return {
       ...context,
@@ -1193,11 +1266,9 @@ async function generateWithTemplate(contexts, config, outputPath, dryRun) {
 async function runPipeline(input, config, dryRun) {
   debug(`Processing ${input.packages.length} package(s)`);
   let contexts = input.packages.map(createTemplateContext);
-  if (config.llm && !process.env.CHANGELOG_NO_LLM && !dryRun) {
+  if (config.llm && !process.env.CHANGELOG_NO_LLM) {
     info4("Processing with LLM enhancement");
     contexts = await Promise.all(contexts.map((ctx) => processWithLLM(ctx, config)));
-  } else if (config.llm && dryRun) {
-    info4("Skipping LLM processing in dry-run mode");
   }
   for (const output of config.output) {
     info4(`Generating ${output.format} output`);