@iodes/releasekit 0.1.7 → 0.2.1

package/dist/install.d.ts

@@ -1,23 +1,56 @@
 import { Project } from './project.js';
 import { type ProjectConfig } from './model.js';
-export declare function installSkills(project: Project): Promise<{
+export declare function installSkills(project: Project, tools?: ProjectConfig['tools']): Promise<{
     tools: ("claude" | "codex" | "cursor")[];
     written: string[];
     conflicts: string[];
+    unchanged: string[];
     hints: {
         codex: string;
         claude: string;
         cursor: string;
     };
 }>;
-export declare function initProject(project: Project, options: {
+export declare function updateProject(project: Project): Promise<{
+    product: string;
+    migrations: string[];
+    backup: null;
+    tools: ("claude" | "codex" | "cursor")[];
+    written: string[];
+    conflicts: string[];
+    unchanged: string[];
+    hints: {
+        codex: string;
+        claude: string;
+        cursor: string;
+    };
+} | {
+    product: string;
+    migrations: string[];
+    backup: string;
+    tools: ("claude" | "codex" | "cursor")[];
+    written: string[];
+    conflicts: string[];
+    unchanged: string[];
+    hints: {
+        codex: string;
+        claude: string;
+        cursor: string;
+    };
+}>;
+export declare function formatUpdate(result: Awaited<ReturnType<typeof updateProject>>): string;
+export interface InitOptions {
     product?: string;
     tools?: ProjectConfig['tools'];
     themes?: ProjectConfig['visuals']['themes'];
-}): Promise<{
+    sourceLocale?: string;
+    locales?: string[];
+}
+export declare function initProject(project: Project, options: InitOptions): Promise<{
     tools: ("claude" | "codex" | "cursor")[];
     written: string[];
     conflicts: string[];
+    unchanged: string[];
     hints: {
         codex: string;
         claude: string;

package/dist/install.js

@@ -3,18 +3,20 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { z } from 'zod';
 import { Project } from './project.js';
+import { migrateConfig } from './migrate-config.js';
 import { configSchema, defaultConfig } from './model.js';
 import { exists, within, write, writeYaml, digest } from './files.js';
 const resources = fileURLToPath(new URL('../kit/', import.meta.url));
 const names = ['releasekit-draft', 'releasekit-image', 'releasekit-finalize'];
 const managedSchema = z.record(z.string(), z.string().regex(/^[a-f0-9]{64}$/));
-export async function installSkills(project) {
+export async function installSkills(project, tools) {
     const config = await project.config();
+    const selected = tools ?? config.tools;
     const marker = await project.content('managed-skills.json');
     const managed = await exists(marker) ? managedSchema.parse(JSON.parse(await fs.readFile(marker, 'utf8'))) : {};
-    const roots = new Set(config.tools.map(tool => tool === 'claude' ? '.claude/skills' : '.agents/skills'));
+    const roots = new Set(selected.map(tool => tool === 'claude' ? '.claude/skills' : '.agents/skills'));
     const references = (await fs.readdir(path.join(resources, 'references'))).filter(file => file.endsWith('.md')).sort();
-    const written = [], conflicts = [];
+    const written = [], conflicts = [], unchanged = [];
     for (const root of roots) {
         for (const name of names) {
             const sourceFiles = [
@@ -29,6 +31,7 @@ export async function installSkills(project) {
                     const actual = digest(await fs.readFile(destination));
                     if (actual === expected) {
                         managed[item.destination] = expected;
+                        unchanged.push(item.destination);
                         continue;
                     }
                     if (actual !== managed[item.destination]) {
@@ -43,12 +46,30 @@ export async function installSkills(project) {
         }
     }
     await write(marker, JSON.stringify(managed, null, 2) + '\n');
-    return { tools: config.tools, written, conflicts, hints: {
+    return { tools: selected, written, conflicts, unchanged, hints: {
             codex: 'Use $releasekit-draft, $releasekit-image, or $releasekit-finalize.',
             claude: 'Use /releasekit-draft, /releasekit-image, or /releasekit-finalize.',
             cursor: 'Use the installed releasekit-* skills from the agent skill picker or name them in your request.',
         } };
 }
+export async function updateProject(project) {
+    const migration = await migrateConfig(project);
+    return { ...await installSkills(project, ['codex', 'claude', 'cursor']), ...migration };
+}
+export function formatUpdate(result) {
+    const lines = [result.conflicts.length ? 'Update needs attention.' : result.tools.length ? 'Skills are up to date.' : 'No agent tools selected.',
+        `  Updated: ${result.written.length} files`, `  Already current: ${result.unchanged.length} files`, `  Modified files preserved: ${result.conflicts.length}`];
+    if (result.migrations.length) {
+        lines.push('', ...result.migrations.map(item => `  Configuration: ${item}`), `  Original configuration: ${result.backup}`);
+    }
+    if (result.conflicts.length) {
+        lines.push('', ...result.conflicts.map(file => `  ! ${file}`), 'Compare these files with the installed package templates and merge the changes you want to keep.');
+    }
+    if (result.tools.length)
+        lines.push('', ...result.tools.map(tool => `  ${tool}: ${result.hints[tool]}`));
+    lines.push('', 'Next: releasekit status');
+    return lines.join('\n');
+}
 export async function initProject(project, options) {
     const file = await project.content('config.yaml');
     if (await exists(file))
@@ -58,6 +79,13 @@ export async function initProject(project, options) {
         config.tools = [...new Set(options.tools)];
     if (options.themes)
         config.visuals.themes = options.themes;
-    await writeYaml(file, configSchema.parse(config));
+    if (options.sourceLocale !== undefined)
+        config.sourceLocale = options.sourceLocale;
+    config.locales = options.locales ?? [config.sourceLocale];
+    configSchema.parse(config);
+    if (!config.locales.includes(config.sourceLocale) || new Set(config.locales).size !== config.locales.length) {
+        throw new Error('Project locales must be unique and include the source locale.');
+    }
+    await writeYaml(file, config);
     return { config: file, ...await installSkills(project) };
 }

package/dist/migrate-config.d.ts

@@ -0,0 +1,10 @@
+import { Project } from './project.js';
+export declare function migrateConfig(project: Project): Promise<{
+    product: string;
+    migrations: string[];
+    backup: null;
+} | {
+    product: string;
+    migrations: string[];
+    backup: string;
+}>;

package/dist/migrate-config.js

@@ -0,0 +1,44 @@
+import * as fs from 'node:fs/promises';
+import { parseDocument } from 'yaml';
+import { Project, parseProjectConfig } from './project.js';
+import { canonical, exists, parseYaml, write } from './files.js';
+export async function migrateConfig(project) {
+    const file = await project.content('config.yaml');
+    if (!(await exists(file)))
+        throw new Error('ReleaseKit is not initialized. Run releasekit init first.');
+    const original = await fs.readFile(file, 'utf8');
+    const raw = parseYaml(original);
+    const migrations = [];
+    if (raw && typeof raw === 'object' && 'history' in raw && raw.history && typeof raw.history === 'object' && 'limit' in raw.history) {
+        delete raw.history.limit;
+        migrations.push('Removed history.limit; use export --limit to limit exported releases. Omit --limit to export all releases.');
+    }
+    // Validate the complete proposed configuration before touching any files.
+    const config = parseProjectConfig(raw);
+    if (!migrations.length)
+        return { product: config.product, migrations, backup: null };
+    const document = parseDocument(original);
+    document.deleteIn(['history', 'limit']);
+    let migrated = document.toString();
+    if (original.includes('\r\n'))
+        migrated = migrated.replace(/\r?\n/g, '\r\n');
+    if (original.startsWith('\uFEFF') && !migrated.startsWith('\uFEFF'))
+        migrated = '\uFEFF' + migrated;
+    if (canonical(parseYaml(migrated)) !== canonical(raw))
+        throw new Error('Configuration migration would change unrelated settings. No files were changed.');
+    const backup = await project.content('config.yaml.before-update');
+    try {
+        await fs.writeFile(backup, original, { flag: 'wx' });
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST')
+            throw error;
+        if (await fs.readFile(backup, 'utf8') !== original) {
+            throw new Error(`A different configuration backup already exists at ${backup}. Move it aside before running update again; no files were overwritten.`);
+        }
+    }
+    if (await fs.readFile(file, 'utf8') !== original)
+        throw new Error('Configuration changed during update. Run update again; the configuration was not overwritten.');
+    await write(file, migrated);
+    return { product: config.product, migrations, backup };
+}

package/dist/model.d.ts

@@ -1,5 +1,16 @@
 import { z } from 'zod';
 export declare const segment: z.ZodString;
+export declare const channelName: z.ZodString;
+export declare const channelRefSchema: z.ZodObject<{
+    channel: z.ZodString;
+    version: z.ZodString;
+}, z.core.$strict>;
+export type ReleaseRef = {
+    version: string;
+    channel?: string;
+};
+export type ReleaseId = string | ReleaseRef;
+export declare const releasedAtSchema: z.ZodUnion<readonly [z.ZodISODate, z.ZodISODateTime]>;
 export declare const sha: z.ZodString;
 export declare const locale: z.ZodString;
 export declare const theme: z.ZodEnum<{
@@ -66,13 +77,33 @@ export declare const historyStartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     version: z.ZodNull;
 }, z.core.$strict>], "past">;
 export type HistoryStart = z.infer<typeof historyStartSchema>;
+export declare const channelsSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    include: z.ZodArray<z.ZodString>;
+    history: z.ZodOptional<z.ZodObject<{
+        start: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            ref: z.ZodString;
+            sha: z.ZodString;
+            past: z.ZodLiteral<"summary">;
+            version: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            ref: z.ZodString;
+            sha: z.ZodString;
+            past: z.ZodLiteral<"history">;
+            version: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            ref: z.ZodString;
+            sha: z.ZodString;
+            past: z.ZodLiteral<"skip">;
+            version: z.ZodNull;
+        }, z.core.$strict>], "past">>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
 export declare const configSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     product: z.ZodString;
     sourceLocale: z.ZodString;
     locales: z.ZodArray<z.ZodString>;
-    history: z.ZodObject<{
-        limit: z.ZodNumber;
+    history: z.ZodOptional<z.ZodObject<{
         start: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
             ref: z.ZodString;
             sha: z.ZodString;
@@ -89,7 +120,28 @@ export declare const configSchema: z.ZodObject<{
             past: z.ZodLiteral<"skip">;
             version: z.ZodNull;
         }, z.core.$strict>], "past">>;
-    }, z.core.$strict>;
+    }, z.core.$strict>>;
+    channels: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<false>, z.ZodRecord<z.ZodString, z.ZodObject<{
+        include: z.ZodArray<z.ZodString>;
+        history: z.ZodOptional<z.ZodObject<{
+            start: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                ref: z.ZodString;
+                sha: z.ZodString;
+                past: z.ZodLiteral<"summary">;
+                version: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                ref: z.ZodString;
+                sha: z.ZodString;
+                past: z.ZodLiteral<"history">;
+                version: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                ref: z.ZodString;
+                sha: z.ZodString;
+                past: z.ZodLiteral<"skip">;
+                version: z.ZodNull;
+            }, z.core.$strict>], "past">>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>]>>;
     visuals: z.ZodObject<{
         themes: z.ZodEnum<{
             both: "both";
@@ -146,8 +198,12 @@ export type NoteMeta = z.infer<typeof noteMetaSchema>;
 export declare const releaseSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     version: z.ZodString;
-    releasedAt: z.ZodISODate;
-    previous: z.ZodNullable<z.ZodString>;
+    channel: z.ZodOptional<z.ZodString>;
+    releasedAt: z.ZodUnion<readonly [z.ZodISODate, z.ZodISODateTime]>;
+    previous: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        channel: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>]>>;
     status: z.ZodEnum<{
         draft: "draft";
         ready: "ready";
@@ -316,10 +372,16 @@ export declare const bundleSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
     currentVersion: z.ZodString;
     locale: z.ZodString;
+    viewChannel: z.ZodOptional<z.ZodString>;
+    currentChannel: z.ZodOptional<z.ZodString>;
     releases: z.ZodArray<z.ZodObject<{
         version: z.ZodString;
-        releasedAt: z.ZodISODate;
-        previous: z.ZodNullable<z.ZodString>;
+        channel: z.ZodOptional<z.ZodString>;
+        releasedAt: z.ZodUnion<readonly [z.ZodISODate, z.ZodISODateTime]>;
+        previous: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            channel: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>]>>;
         notes: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             category: z.ZodEnum<{

package/dist/model.js

@@ -1,5 +1,8 @@
 import { z } from 'zod';
 export const segment = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._+-]{0,95}$/);
+export const channelName = z.string().regex(/^(?!(?:con|prn|aux|nul|com[1-9]|lpt[1-9])$)[a-z][a-z0-9-]{0,62}$/);
+export const channelRefSchema = z.strictObject({ channel: channelName, version: segment });
+export const releasedAtSchema = z.union([z.iso.date(), z.iso.datetime({ offset: true }).regex(/T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})$/)]);
 export const sha = z.string().regex(/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/);
 export const locale = z.string().regex(/^[a-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/);
 export const theme = z.enum(['dark', 'light']);
@@ -27,10 +30,25 @@ export const historyStartSchema = z.discriminatedUnion('past', [
     z.strictObject({ ref: z.string().min(1), sha, past: z.literal('history'), version: segment }),
     z.strictObject({ ref: z.string().min(1), sha, past: z.literal('skip'), version: z.null() }),
 ]);
+const historySettings = z.strictObject({ start: historyStartSchema.optional() });
+export const channelsSchema = z.record(channelName, z.strictObject({
+    include: z.array(channelName).min(1), history: historySettings.optional(),
+})).superRefine((channels, ctx) => {
+    if (!Object.keys(channels).length)
+        ctx.addIssue({ code: 'custom', message: 'Use channels: false to disable channels.' });
+    for (const [name, settings] of Object.entries(channels)) {
+        if (new Set(settings.include).size !== settings.include.length)
+            ctx.addIssue({ code: 'custom', path: [name, 'include'], message: 'Included channels must be unique.' });
+        for (const included of settings.include)
+            if (!Object.hasOwn(channels, included))
+                ctx.addIssue({ code: 'custom', path: [name, 'include'], message: `Unknown included channel: ${included}` });
+    }
+});
 export const configSchema = z.strictObject({
     schemaVersion: z.literal(1), product: z.string().min(1),
     sourceLocale: locale, locales: z.array(locale).min(1),
-    history: z.strictObject({ limit: z.number().int().min(1).max(100), start: historyStartSchema.optional() }),
+    history: historySettings.optional(),
+    channels: z.union([z.literal(false), channelsSchema]).optional(),
     visuals: visualPolicySchema,
     tools: z.array(z.enum(['codex', 'claude', 'cursor'])),
 });
@@ -43,12 +61,16 @@ export const noteMetaSchema = z.strictObject({
     commits: z.array(sha), paths: z.array(z.string()), image: z.boolean(),
 });
 export const releaseSchema = z.strictObject({
-    schemaVersion: z.literal(1), version: segment, releasedAt: z.iso.date(),
-    previous: segment.nullable(), status: z.enum(['draft', 'ready']),
+    schemaVersion: z.literal(1), version: segment, channel: channelName.optional(), releasedAt: releasedAtSchema,
+    previous: z.union([segment, channelRefSchema]).nullable(), status: z.enum(['draft', 'ready']),
     source: sourceSchema, initialContent: z.enum(['summary', 'history']).optional(),
     sourceLocale: locale, locales: z.array(locale).min(1),
     visuals: visualPolicySchema, notes: z.array(noteMetaSchema),
     emptyReason: z.string().nullable(), contentHash: z.string().nullable(),
+}).superRefine((release, ctx) => {
+    if (release.previous !== null && (release.channel === undefined ? typeof release.previous !== 'string' : typeof release.previous === 'string')) {
+        ctx.addIssue({ code: 'custom', path: ['previous'], message: 'Channel releases require a channel/version predecessor; unchanneled releases require a version string.' });
+    }
 });
 export const noteTextSchema = z.strictObject({
     title: z.string().min(1), alt: z.string(), sourceHash: z.string().nullable(),
@@ -80,8 +102,9 @@ const exportedImage = z.strictObject({
 });
 export const bundleSchema = z.strictObject({
     schemaVersion: z.literal(1), currentVersion: segment, locale,
+    viewChannel: channelName.optional(), currentChannel: channelName.optional(),
     releases: z.array(z.strictObject({
-        version: segment, releasedAt: z.iso.date(), previous: segment.nullable(),
+        version: segment, channel: channelName.optional(), releasedAt: releasedAtSchema, previous: z.union([segment, channelRefSchema]).nullable(),
         notes: z.array(z.strictObject({
             id: segment, category: noteMetaSchema.shape.category, title: z.string(), bodyMarkdown: z.string(),
             image: z.strictObject({
@@ -119,7 +142,7 @@ export function activeVariants(visual, policy) {
 export function defaultConfig(product) {
     return {
         schemaVersion: 1, product, sourceLocale: 'en-US', locales: ['en-US'],
-        history: { limit: 3 }, tools: ['codex', 'claude', 'cursor'],
+        tools: ['codex', 'claude', 'cursor'],
         visuals: {
             themes: 'both', preset: 'quiet-product', width: 1280, height: 800, accent: '#4678ED',
             dark: { canvas: '#242527', surface: '#18191B', raised: '#343638', primary: '#B9BBBE', secondary: '#777B80', divider: '#46494D' },

package/dist/move.d.ts

@@ -0,0 +1,24 @@
+import { Project } from './project.js';
+import { type ReleaseRef } from './model.js';
+export interface MoveOptions {
+    fromChannel?: string;
+    toChannel?: string;
+    toUnchanneled?: boolean;
+    after?: string;
+    atStart?: boolean;
+    dryRun?: boolean;
+}
+export declare function moveReleases(project: Project, versions: string[], options: MoveOptions): Promise<{
+    dryRun: boolean;
+    moved: {
+        from: ReleaseRef;
+        to: ReleaseRef;
+        status: "draft" | "ready";
+    }[];
+    updatedReleases: ReleaseRef[];
+    updatedFiles: string[];
+    paths: {
+        from: string;
+        to: string;
+    }[];
+}>;