@carllee1983/tagsmith 0.2.0

package/dist/cli/implicit.js

@@ -0,0 +1,20 @@
+import { color, info } from "./ui.js";
+/** Extra JSON fields when config was inferred rather than loaded from disk. */
+export function implicitConfigJson(resolved) {
+    if (resolved.source === "file")
+        return {};
+    const line = resolved.config.lines[0];
+    return {
+        configSource: resolved.source,
+        pattern: line.pattern,
+    };
+}
+/** One-time human notice that implicit semver defaults are in use. */
+export function printImplicitConfigNotice(resolved, json) {
+    if (json || resolved.source === "file")
+        return;
+    const line = resolved.config.lines[0];
+    const kind = resolved.source === "inferred" ? "inferred" : "default";
+    info(`${color.dim("ℹ")} No ${color.bold(".tagsmith.json")} — using ${kind} semver defaults (pattern: ${line.pattern}).`);
+    info(`  ${color.dim("Run `tagsmith init` to customize, or commit .tagsmith.json for the team.")}`);
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { runInit } from "./init.js";
+import { runList } from "./list.js";
+import { runNext } from "./next.js";
+import { runCreate } from "./create.js";
+import { runGuide } from "./guide.js";
+import { runCheck } from "./check.js";
+import { printError } from "./ui.js";
+const program = new Command();
+program
+    .name("tagsmith")
+    .description("Define git tag specs, view tags, and generate the next git tag safely.")
+    .version("0.1.0");
+program.addHelpText("beforeAll", "\n  Tagsmith — define a tag spec, then safely compute and create git tags.\n" +
+    "  First time here? Run `tagsmith init`, or `tagsmith guide` for a walkthrough.\n");
+program.addHelpText("after", `
+Examples:
+  $ tagsmith init                          Define the tag spec (interactive)
+  $ tagsmith guide                         Step-by-step walkthrough
+  $ tagsmith list                          Inspect existing tags
+  $ tagsmith check v1.2.3                  Validate a tag against the spec
+  $ tagsmith next --level minor            Preview the next tag
+  $ tagsmith next --tag release            Compute next on a named tag line
+  $ tagsmith create --level minor --push   Create and push the next tag
+`);
+program
+    .command("init")
+    .description("Create a .tagsmith.json tag spec for this repo")
+    .option("--pattern <pattern>", "tag pattern, must contain {version}")
+    .option("--model <type>", "version model: semver | calver | build")
+    .option("--initial-version <version>", "initial version")
+    .option("--push", "push tags by default on create")
+    .option("--force", "overwrite an existing config")
+    .option("-y, --yes", "non-interactive; use flags/defaults")
+    .action(async (opts) => {
+    process.exitCode = await runInit(process.cwd(), opts);
+});
+program
+    .command("guide")
+    .description("Interactive walkthrough: init → list → next → create")
+    .action(async () => {
+    process.exitCode = await runGuide(process.cwd());
+});
+program
+    .command("list")
+    .alias("ls")
+    .description("List git tags, sorted and validated against the spec")
+    .option("--json", "output JSON")
+    .option("-t, --tag <name>", "list only the named tag line")
+    .option("--all", "list every tag line plus unassigned tags")
+    .action(async (opts) => {
+    process.exitCode = await runList(process.cwd(), opts);
+});
+program
+    .command("next")
+    .description("Compute the next tag without creating it")
+    .option("-l, --level <level>", "bump level: major | minor | patch | prerelease | auto", "patch")
+    .option("--json", "output JSON")
+    .option("-t, --tag <name>", "operate on the named tag line (default: the config's default line)")
+    .action(async (opts) => {
+    process.exitCode = await runNext(process.cwd(), opts);
+});
+program
+    .command("check [tags...]")
+    .description("Validate tags against the spec; with no args, lint all repo tags")
+    .option("--json", "output JSON")
+    .option("-t, --tag <name>", "validate only against the named tag line")
+    .action(async (tags, opts) => {
+    process.exitCode = await runCheck(process.cwd(), tags, opts);
+});
+const createCommand = program
+    .command("create")
+    .description("Create the next (or an explicit) git tag")
+    .option("-l, --level <level>", "bump level: major | minor | patch | prerelease | auto", "patch")
+    .option("--set-version <version>", "create an explicit version instead of bumping")
+    .option("-m, --message <message>", "annotate the tag with a message")
+    .option("--push", "push the tag after creating")
+    .option("--dry-run", "preview without creating")
+    .option("--allow-out-of-order", "permit a version not greater than latest")
+    .option("-t, --tag <name>", "operate on the named tag line (default: the config's default line)")
+    .action(async (opts) => {
+    process.exitCode = await runCreate(process.cwd(), opts);
+});
+createCommand.addHelpText("after", `
+Examples:
+  $ tagsmith create                        Create the next patch tag
+  $ tagsmith create -l minor -m "..."      Create an annotated minor tag
+  $ tagsmith create --set-version 2.0.0    Create an explicit version
+  $ tagsmith create --dry-run              Preview without creating
+  $ tagsmith create --tag release          Create the next tag on a named tag line
+`);
+program.parseAsync(process.argv).catch((err) => {
+    printError(err);
+    process.exitCode = 1;
+});

package/dist/cli/init.d.ts

@@ -0,0 +1,11 @@
+export interface InitFlags {
+    pattern?: string;
+    model?: string;
+    initialVersion?: string;
+    push?: boolean;
+    force?: boolean;
+    yes?: boolean;
+    hints?: boolean;
+}
+/** Run the `init` command. Returns the process exit code. */
+export declare function runInit(cwd: string, flags: InitFlags): Promise<number>;

package/dist/cli/init.js

@@ -0,0 +1,127 @@
+import * as p from "@clack/prompts";
+import { CONFIG_FILENAME, configExists, writeConfig, } from "../core/config.js";
+import { printError, success } from "./ui.js";
+import { printNextStepsAfterInit } from "./guidance.js";
+/** Run the `init` command. Returns the process exit code. */
+export async function runInit(cwd, flags) {
+    if ((await configExists(cwd)) && flags.force !== true) {
+        printError(`${CONFIG_FILENAME} already exists. Use --force to overwrite.`);
+        return 1;
+    }
+    const config = flags.yes
+        ? buildFromFlags(flags)
+        : await promptForConfig(flags);
+    if (config === null) {
+        printError("Aborted.");
+        return 1;
+    }
+    await writeConfig(cwd, config);
+    success(`Wrote ${CONFIG_FILENAME}`);
+    if (flags.hints !== false)
+        printNextStepsAfterInit({});
+    return 0;
+}
+function buildFromFlags(flags) {
+    const modelType = (flags.model ?? "semver");
+    return {
+        lines: [
+            {
+                name: "default",
+                pattern: flags.pattern ?? "v{version}",
+                model: defaultModel(modelType),
+                initialVersion: flags.initialVersion ?? defaultInitial(modelType),
+                push: flags.push ?? false,
+            },
+        ],
+        default: "default",
+    };
+}
+async function promptForConfig(flags) {
+    p.intro("tagsmith init");
+    const pattern = await p.text({
+        message: "Tag pattern (must contain {version})",
+        initialValue: flags.pattern ?? "v{version}",
+        validate: (v) => v.includes("{version}") ? undefined : "Must contain {version}",
+    });
+    if (p.isCancel(pattern))
+        return null;
+    const modelType = (await p.select({
+        message: "Version model",
+        initialValue: (flags.model ?? "semver"),
+        options: [
+            { value: "semver", label: "SemVer (1.2.3)" },
+            { value: "calver", label: "CalVer (2026.06.0)" },
+            { value: "build", label: "Build number (42)" },
+        ],
+    }));
+    if (p.isCancel(modelType))
+        return null;
+    const model = await promptModelDetails(modelType);
+    if (model === null)
+        return null;
+    const initialVersion = await p.text({
+        message: "Initial version (used when no tag exists yet)",
+        initialValue: flags.initialVersion ?? defaultInitial(modelType),
+    });
+    if (p.isCancel(initialVersion))
+        return null;
+    const push = await p.confirm({
+        message: "Push tags by default on create?",
+        initialValue: flags.push ?? false,
+    });
+    if (p.isCancel(push))
+        return null;
+    p.outro("Configured.");
+    return {
+        lines: [{ name: "default", pattern, model, initialVersion, push }],
+        default: "default",
+    };
+}
+async function promptModelDetails(type) {
+    if (type === "semver") {
+        const allowPrerelease = await p.confirm({
+            message: "Allow prerelease versions (e.g. 1.2.3-rc.1)?",
+            initialValue: true,
+        });
+        if (p.isCancel(allowPrerelease))
+            return null;
+        return { type: "semver", allowPrerelease };
+    }
+    if (type === "calver") {
+        const format = await p.text({
+            message: "CalVer format (tokens: YYYY YY MM DD MICRO)",
+            initialValue: "YYYY.MM.MICRO",
+        });
+        if (p.isCancel(format))
+            return null;
+        return { type: "calver", format };
+    }
+    const padding = await p.text({
+        message: "Zero-pad build number to width (0 = none)",
+        initialValue: "0",
+        validate: (v) => (/^\d+$/.test(v) ? undefined : "Must be a number"),
+    });
+    if (p.isCancel(padding))
+        return null;
+    return { type: "build", padding: Number(padding) };
+}
+function defaultModel(type) {
+    switch (type) {
+        case "semver":
+            return { type: "semver", allowPrerelease: true };
+        case "calver":
+            return { type: "calver", format: "YYYY.MM.MICRO" };
+        case "build":
+            return { type: "build", padding: 0 };
+    }
+}
+function defaultInitial(type) {
+    switch (type) {
+        case "semver":
+            return "0.1.0";
+        case "calver":
+            return "2026.06.0";
+        case "build":
+            return "1";
+    }
+}

package/dist/cli/list.d.ts

@@ -0,0 +1,6 @@
+export interface ListFlags {
+    json?: boolean;
+    tag?: string;
+    all?: boolean;
+}
+export declare function runList(cwd: string, flags: ListFlags): Promise<number>;

package/dist/cli/list.js

@@ -0,0 +1,124 @@
+import { compilePattern } from "../core/pattern.js";
+import { createModel } from "../core/models/index.js";
+import { analyzeTags } from "../core/analyze.js";
+import { assignTagsToLines, selectLine } from "../core/lines.js";
+import { ensureRepo, listTags } from "../git/git.js";
+import { color, info, printError, warn } from "./ui.js";
+import { resolveConfig } from "./resolve-config.js";
+import { implicitConfigJson, printImplicitConfigNotice } from "./implicit.js";
+/** Render the conforming + anomaly listing for an analysis (human-readable). */
+function printAnalysisBody(analysis) {
+    info(color.bold("Conforming tags (newest first):"));
+    if (analysis.conforming.length === 0) {
+        info("  (none)");
+    }
+    analysis.conforming.forEach((t, i) => {
+        const marker = i === 0 ? color.green(" ← latest") : "";
+        info(`  ${color.cyan(t.raw)}${marker}`);
+    });
+    if (analysis.anomalies.length > 0) {
+        info("");
+        warn(`${analysis.anomalies.length} non-conforming tag(s):`);
+        for (const t of analysis.anomalies) {
+            info(`  ${color.yellow(t.raw)} ${color.dim(`(${t.anomaly})`)}`);
+        }
+    }
+}
+/** Serialise an analysis to the shared `--json` shape. */
+function analysisToJson(analysis) {
+    return {
+        conforming: analysis.conforming.map((t) => ({
+            tag: t.raw,
+            version: t.versionString,
+        })),
+        anomalies: analysis.anomalies.map((t) => ({
+            tag: t.raw,
+            reason: t.anomaly,
+        })),
+        latest: analysis.latest?.raw ?? null,
+    };
+}
+/** Print the analysis for a single named line (human-readable, with header). */
+function printLineSection(lineName, analysis) {
+    info(color.bold(`\n── Line: ${lineName} ──`));
+    if (analysis.conforming.length === 0 && analysis.anomalies.length === 0) {
+        info("  (no tags)");
+        return;
+    }
+    printAnalysisBody(analysis);
+}
+/** Print the orphan tags section (human-readable). */
+function printOrphans(orphans) {
+    info(color.bold("\n── Unassigned / orphan tags ──"));
+    for (const t of orphans) {
+        info(`  ${color.yellow(t)}`);
+    }
+}
+export async function runList(cwd, flags) {
+    try {
+        const resolved = await resolveConfig(cwd);
+        const { config } = resolved;
+        await ensureRepo({ cwd });
+        const allTags = await listTags({ cwd });
+        const assignment = assignTagsToLines(allTags, config.lines);
+        if (flags.all && flags.tag) {
+            printError("--all and --tag are mutually exclusive.");
+            return 1;
+        }
+        if (flags.all) {
+            if (flags.json) {
+                const lines = config.lines.map((line) => {
+                    const model = createModel(line.model);
+                    const pattern = compilePattern(line.pattern);
+                    const lineTags = assignment.byLine.get(line.name) ?? [];
+                    const analysis = analyzeTags(lineTags, pattern, model);
+                    return { line: line.name, ...analysisToJson(analysis) };
+                });
+                info(JSON.stringify({
+                    lines,
+                    orphans: assignment.orphans,
+                    ...implicitConfigJson(resolved),
+                }, null, 2));
+                return 0;
+            }
+            // Human-readable --all output
+            for (const line of config.lines) {
+                const model = createModel(line.model);
+                const pattern = compilePattern(line.pattern);
+                const lineTags = assignment.byLine.get(line.name) ?? [];
+                const analysis = analyzeTags(lineTags, pattern, model);
+                printLineSection(line.name, analysis);
+            }
+            if (assignment.orphans.length > 0) {
+                printOrphans(assignment.orphans);
+            }
+            return 0;
+        }
+        // Single-line path: default or --tag <name>
+        const line = selectLine(config, flags.tag);
+        const model = createModel(line.model);
+        const pattern = compilePattern(line.pattern);
+        const lineTags = assignment.byLine.get(line.name) ?? [];
+        // Single-line config: feed allTags so non-matching tags appear as pattern-mismatch
+        // anomalies — preserves backward-compatible behaviour (allTags === lineTags + orphans).
+        // Multi-line config: feed only this line's own bucket (spec 5.3); orphans belong to
+        // the `list --all` view and must NOT pollute a single-line analysis.
+        const tagsForAnalysis = config.lines.length === 1 ? allTags : lineTags;
+        const analysis = analyzeTags(tagsForAnalysis, pattern, model);
+        if (flags.json) {
+            info(JSON.stringify({ line: line.name, ...analysisToJson(analysis), ...implicitConfigJson(resolved) }, null, 2));
+            return 0;
+        }
+        printImplicitConfigNotice(resolved, flags.json);
+        if (analysis.conforming.length === 0 && analysis.anomalies.length === 0) {
+            info("No tags found.");
+            return 0;
+        }
+        printAnalysisBody(analysis);
+        return 0;
+    }
+    catch (err) {
+        printError(err);
+        return 1;
+    }
+}

package/dist/cli/next.d.ts

@@ -0,0 +1,7 @@
+export interface NextFlags {
+    level?: string;
+    json?: boolean;
+    hints?: boolean;
+    tag?: string;
+}
+export declare function runNext(cwd: string, flags: NextFlags): Promise<number>;

package/dist/cli/next.js

@@ -0,0 +1,57 @@
+import { createModel } from "../core/models/index.js";
+import { planNext } from "../core/plan.js";
+import { assignTagsToLines, selectLine } from "../core/lines.js";
+import { ensureRepo, listTags } from "../git/git.js";
+import { color, info, printError, warn } from "./ui.js";
+import { printNextStepsAfterNext } from "./guidance.js";
+import { resolveConfig } from "./resolve-config.js";
+import { implicitConfigJson, printImplicitConfigNotice } from "./implicit.js";
+const LEVELS = ["major", "minor", "patch", "prerelease", "auto"];
+export async function runNext(cwd, flags) {
+    try {
+        const level = resolveLevel(flags.level);
+        const resolved = await resolveConfig(cwd);
+        const { config } = resolved;
+        await ensureRepo({ cwd });
+        const line = selectLine(config, flags.tag);
+        const model = createModel(line.model);
+        const allTags = await listTags({ cwd });
+        const lineTags = assignTagsToLines(allTags, config.lines).byLine.get(line.name) ?? [];
+        const plan = planNext(line, model, lineTags, level);
+        if (plan.fresh && plan.analysis.anomalies.length > 0 && !flags.json) {
+            warn(`${plan.analysis.anomalies.length} non-conforming tag(s) ignored; treating repo as having no prior version. Run \`tagsmith list\` to inspect.`);
+        }
+        if (flags.json) {
+            info(JSON.stringify({
+                tag: plan.tag,
+                version: plan.version,
+                fromVersion: plan.fromVersion,
+                fresh: plan.fresh,
+                line: line.name,
+                ...implicitConfigJson(resolved),
+            }, null, 2));
+            return 0;
+        }
+        printImplicitConfigNotice(resolved, flags.json);
+        if (plan.fresh) {
+            info(`${color.cyan(plan.tag)} ${color.dim("(initial — no prior tag)")}`);
+        }
+        else {
+            info(`${color.cyan(plan.tag)} ${color.dim(`(from ${plan.fromVersion})`)}`);
+        }
+        if (flags.hints !== false)
+            printNextStepsAfterNext({ level, json: flags.json });
+        return 0;
+    }
+    catch (err) {
+        printError(err);
+        return 1;
+    }
+}
+function resolveLevel(raw) {
+    if (raw === undefined)
+        return "patch";
+    if (LEVELS.includes(raw))
+        return raw;
+    throw new Error(`Invalid level "${raw}". Expected one of: ${LEVELS.join(", ")}`);
+}

package/dist/cli/resolve-config.d.ts

@@ -0,0 +1,6 @@
+import { type ResolvedConfig } from "../core/config.js";
+/**
+ * Load `.tagsmith.json` when present; otherwise build semver defaults from
+ * `hintTags` or the repo's existing tags.
+ */
+export declare function resolveConfig(cwd: string, hintTags?: readonly string[]): Promise<ResolvedConfig>;

package/dist/cli/resolve-config.js

@@ -0,0 +1,16 @@
+import { buildImplicitConfig, configExists, loadConfig, } from "../core/config.js";
+import { ensureRepo, listTags } from "../git/git.js";
+/**
+ * Load `.tagsmith.json` when present; otherwise build semver defaults from
+ * `hintTags` or the repo's existing tags.
+ */
+export async function resolveConfig(cwd, hintTags) {
+    if (await configExists(cwd)) {
+        return { config: await loadConfig(cwd), source: "file" };
+    }
+    if (hintTags !== undefined && hintTags.length > 0) {
+        return buildImplicitConfig(hintTags);
+    }
+    await ensureRepo({ cwd });
+    return buildImplicitConfig(await listTags({ cwd }));
+}

package/dist/cli/ui.d.ts

@@ -0,0 +1,8 @@
+/** Print an error to stderr in a consistent, friendly format. */
+export declare function printError(err: unknown): void;
+export declare function info(msg: string): void;
+export declare function success(msg: string): void;
+export declare function warn(msg: string): void;
+export declare const color: import("picocolors/types").Colors & {
+    createColors: (enabled?: boolean) => import("picocolors/types").Colors;
+};

package/dist/cli/ui.js

@@ -0,0 +1,16 @@
+import pc from "picocolors";
+/** Print an error to stderr in a consistent, friendly format. */
+export function printError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`${pc.red("✖")} ${message}\n`);
+}
+export function info(msg) {
+    process.stdout.write(`${msg}\n`);
+}
+export function success(msg) {
+    process.stdout.write(`${pc.green("✔")} ${msg}\n`);
+}
+export function warn(msg) {
+    process.stdout.write(`${pc.yellow("!")} ${msg}\n`);
+}
+export const color = pc;

package/dist/core/analyze.d.ts

@@ -0,0 +1,21 @@
+import type { CompiledPattern } from "./pattern.js";
+import type { ParsedTag, VersionModel } from "../types.js";
+export interface AnalyzedTag extends ParsedTag {
+    /** True when the tag matches the pattern and the version parses. */
+    conforming: boolean;
+}
+export interface Analysis {
+    /** Conforming tags sorted newest → oldest by version. */
+    conforming: AnalyzedTag[];
+    /** Tags that failed pattern or version parsing, in input order. */
+    anomalies: AnalyzedTag[];
+    /** The highest conforming version, or null when none exist. */
+    latest: AnalyzedTag | null;
+}
+/**
+ * Classify a list of raw git tag names against the configured pattern + model,
+ * sort the conforming ones by semantic version (newest first), and surface
+ * format / duplicate anomalies.
+ */
+export declare function analyzeTags(tags: readonly string[], pattern: CompiledPattern, model: VersionModel): Analysis;
+export declare function classify(raw: string, pattern: CompiledPattern, model: VersionModel): AnalyzedTag;

package/dist/core/analyze.js

@@ -0,0 +1,55 @@
+/**
+ * Classify a list of raw git tag names against the configured pattern + model,
+ * sort the conforming ones by semantic version (newest first), and surface
+ * format / duplicate anomalies.
+ */
+export function analyzeTags(tags, pattern, model) {
+    const parsed = tags.map((raw) => classify(raw, pattern, model));
+    // Detect duplicate versions among otherwise-conforming tags.
+    const seen = new Map();
+    for (const tag of parsed) {
+        if (tag.version === null || tag.versionString === null)
+            continue;
+        const key = model.format(tag.version);
+        const prior = seen.get(key);
+        if (prior === undefined) {
+            seen.set(key, tag);
+        }
+        else {
+            tag.anomaly = "duplicate-version";
+            tag.conforming = false;
+        }
+    }
+    const conforming = parsed
+        .filter((t) => t.conforming)
+        .sort((a, b) => model.compare(b.version, a.version));
+    const anomalies = parsed.filter((t) => !t.conforming);
+    return {
+        conforming,
+        anomalies,
+        latest: conforming[0] ?? null,
+    };
+}
+export function classify(raw, pattern, model) {
+    const versionString = pattern.extract(raw);
+    if (versionString === null) {
+        return {
+            raw,
+            versionString: null,
+            version: null,
+            anomaly: "pattern-mismatch",
+            conforming: false,
+        };
+    }
+    const version = model.parse(versionString);
+    if (version === null) {
+        return {
+            raw,
+            versionString,
+            version: null,
+            anomaly: "unparseable-version",
+            conforming: false,
+        };
+    }
+    return { raw, versionString, version, anomaly: null, conforming: true };
+}

package/dist/core/check.d.ts

@@ -0,0 +1,15 @@
+import type { CompiledPattern } from "./pattern.js";
+import type { TagAnomaly, VersionModel } from "../types.js";
+export interface TagCheck {
+    tag: string;
+    ok: boolean;
+    anomaly: TagAnomaly | null;
+}
+export interface CheckResult {
+    ok: boolean;
+    checks: TagCheck[];
+}
+/**
+ * 驗證候選 tag 是否符合 pattern + model。純函式，無 IO。
+ */
+export declare function checkTags(pattern: CompiledPattern, model: VersionModel, candidates: readonly string[], existing: readonly string[]): CheckResult;

package/dist/core/check.js

@@ -0,0 +1,27 @@
+import { classify } from "./analyze.js";
+/**
+ * 驗證候選 tag 是否符合 pattern + model。純函式，無 IO。
+ */
+export function checkTags(pattern, model, candidates, existing) {
+    // 既有 conforming 版本的鍵集合。
+    const seen = new Set();
+    for (const raw of existing) {
+        const c = classify(raw, pattern, model);
+        if (c.conforming && c.version !== null) {
+            seen.add(model.format(c.version));
+        }
+    }
+    const checks = candidates.map((tag) => {
+        const c = classify(tag, pattern, model);
+        if (!c.conforming) {
+            return { tag, ok: false, anomaly: c.anomaly };
+        }
+        const key = model.format(c.version);
+        if (seen.has(key)) {
+            return { tag, ok: false, anomaly: "duplicate-version" };
+        }
+        seen.add(key);
+        return { tag, ok: true, anomaly: null };
+    });
+    return { ok: checks.every((c) => c.ok), checks };
+}

package/dist/core/config.d.ts

@@ -0,0 +1,21 @@
+import type { TagsmithConfig } from "../types.js";
+export declare const CONFIG_FILENAME = ".tagsmith.json";
+export declare class ConfigError extends Error {
+}
+/** Thrown by loadConfig when no config file exists (vs. a malformed one). */
+export declare class MissingConfigError extends ConfigError {
+}
+export type ConfigSource = "file" | "inferred" | "default";
+export interface ResolvedConfig {
+    config: TagsmithConfig;
+    source: ConfigSource;
+}
+/** Build semver defaults, inferring pattern from existing tag names when possible. */
+export declare function buildImplicitConfig(tags: readonly string[]): ResolvedConfig;
+/** Parse, normalise and validate a raw config. Throws ConfigError on failure. */
+export declare function parseConfig(raw: unknown): TagsmithConfig;
+export declare function configPath(cwd: string): string;
+export declare function configExists(cwd: string): Promise<boolean>;
+/** Load and validate the config from `cwd`. Throws ConfigError when missing. */
+export declare function loadConfig(cwd: string): Promise<TagsmithConfig>;
+export declare function writeConfig(cwd: string, config: TagsmithConfig): Promise<void>;