@shazhou/proman-core 0.9.0

package/dist/commands/init.js

@@ -0,0 +1,262 @@
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+function jsonStringify(obj) {
+    return JSON.stringify(obj, null, 2);
+}
+/**
+ * Sanitize a directory name into a valid npm package name segment.
+ *
+ * Rules applied (per https://github.com/npm/validate-npm-package-name):
+ * - lowercase only
+ * - strip characters not in `[a-z0-9._-]` (replaces with hyphens)
+ * - strip leading `.`, `_`, or `-`
+ * - collapse consecutive hyphens
+ * - enforce 214-character npm limit
+ * - fall back to `'my-project'` if nothing remains
+ */
+function toPackageName(dirName) {
+    return (dirName
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]/g, '-') // replace invalid chars
+        .replace(/^[._-]+/, '') // strip leading dots/hyphens/underscores
+        .replace(/-+/g, '-') // collapse consecutive hyphens
+        .slice(0, 214) || // npm name length limit
+        'my-project'); // fallback if everything was stripped
+}
+export async function init(opts) {
+    const targetDir = resolve(opts.targetDir);
+    const projectName = toPackageName(basename(targetDir));
+    // Check if directory is empty
+    if (existsSync(targetDir)) {
+        const entries = readdirSync(targetDir);
+        if (entries.length > 0) {
+            throw new Error(`Directory is not empty: ${targetDir}`);
+        }
+    }
+    else {
+        mkdirSync(targetDir, { recursive: true });
+    }
+    // Create root files
+    createRootPackageJson(targetDir, projectName);
+    createPromanYaml(targetDir, projectName);
+    createPnpmWorkspace(targetDir);
+    createBiomeJson(targetDir);
+    createTsConfig(targetDir);
+    createGitignore(targetDir);
+    // Create packages
+    createCorePackage(targetDir, projectName);
+    createCliPackage(targetDir, projectName);
+    // Format all JSON files with biome
+    try {
+        execSync('pnpm exec biome format --write .', { cwd: targetDir, stdio: 'ignore' });
+    }
+    catch {
+        // Ignore biome formatting errors during init - user can run format later
+    }
+    // Print post-init message
+    console.log(`✓ Created monorepo in ${targetDir}`);
+    console.log('');
+    console.log('Next steps:');
+    if (targetDir !== process.cwd()) {
+        console.log(`  cd ${projectName}`);
+    }
+    console.log('  pnpm install');
+    console.log('  proman build');
+}
+function createRootPackageJson(targetDir, projectName) {
+    const content = {
+        name: projectName,
+        private: true,
+        type: 'module',
+        scripts: {
+            build: 'proman build',
+            test: 'proman test',
+            check: 'proman check',
+            format: 'proman format',
+        },
+        devDependencies: {
+            '@biomejs/biome': '^2.4.16',
+            '@shazhou/proman': '^0.7.0',
+            '@types/node': '^22.0.0',
+            typescript: '^5.9.3',
+            vitest: '^4.1.8',
+        },
+    };
+    writeFileSync(join(targetDir, 'package.json'), `${jsonStringify(content)}\n`);
+}
+function createPromanYaml(targetDir, projectName) {
+    const content = `packages:
+  - name: '@${projectName}/core'
+    path: packages/core
+    type: lib
+  - name: '@${projectName}/cli'
+    path: packages/cli
+    type: cli
+`;
+    writeFileSync(join(targetDir, 'proman.yaml'), content);
+}
+function createPnpmWorkspace(targetDir) {
+    const content = `packages:
+  - 'packages/*'
+
+allowBuilds:
+  esbuild: true
+`;
+    writeFileSync(join(targetDir, 'pnpm-workspace.yaml'), content);
+}
+function createBiomeJson(targetDir) {
+    const content = {
+        $schema: 'https://biomejs.dev/schemas/2.4.16/schema.json',
+        assist: { actions: { source: { organizeImports: 'on' } } },
+        linter: {
+            enabled: true,
+            rules: { recommended: true },
+        },
+        formatter: {
+            enabled: true,
+            indentStyle: 'space',
+            indentWidth: 2,
+            lineWidth: 100,
+        },
+        javascript: {
+            formatter: {
+                quoteStyle: 'single',
+                semicolons: 'asNeeded',
+                trailingCommas: 'all',
+            },
+        },
+        files: {
+            includes: ['**', '!**/dist', '!**/node_modules', '!**/tests/fixtures', '!.worktrees'],
+        },
+    };
+    writeFileSync(join(targetDir, 'biome.json'), `${jsonStringify(content)}\n`);
+}
+function createTsConfig(targetDir) {
+    const content = {
+        compilerOptions: {
+            target: 'ESNext',
+            module: 'ESNext',
+            moduleResolution: 'bundler',
+            strict: true,
+            skipLibCheck: true,
+            verbatimModuleSyntax: true,
+            esModuleInterop: true,
+            resolveJsonModule: true,
+            types: ['node'],
+            lib: ['ESNext'],
+        },
+        references: [{ path: './packages/core' }, { path: './packages/cli' }],
+    };
+    writeFileSync(join(targetDir, 'tsconfig.json'), `${jsonStringify(content)}\n`);
+}
+function createGitignore(targetDir) {
+    const content = `node_modules
+dist
+.proman
+*.tsbuildinfo
+`;
+    writeFileSync(join(targetDir, '.gitignore'), content);
+}
+function createCorePackage(targetDir, projectName) {
+    const pkgDir = join(targetDir, 'packages', 'core');
+    mkdirSync(join(pkgDir, 'src'), { recursive: true });
+    // package.json
+    const packageJson = {
+        name: `@${projectName}/core`,
+        version: '0.0.1',
+        type: 'module',
+        exports: {
+            '.': {
+                types: './dist/index.d.ts',
+                default: './dist/index.js',
+            },
+        },
+        files: ['dist'],
+        scripts: {
+            build: 'tsc --build',
+        },
+    };
+    writeFileSync(join(pkgDir, 'package.json'), `${jsonStringify(packageJson)}\n`);
+    // tsconfig.json
+    const tsConfig = {
+        extends: '../../tsconfig.json',
+        compilerOptions: {
+            composite: true,
+            outDir: 'dist',
+            rootDir: 'src',
+            noEmit: false,
+            declaration: true,
+        },
+        include: ['src/**/*'],
+    };
+    writeFileSync(join(pkgDir, 'tsconfig.json'), `${jsonStringify(tsConfig)}\n`);
+    // src/index.ts
+    const indexTs = `export function hello(): string {
+  return 'hello'
+}
+`;
+    writeFileSync(join(pkgDir, 'src', 'index.ts'), indexTs);
+    // src/index.test.ts
+    const testTs = `import { describe, expect, test } from 'vitest'
+import { hello } from './index.js'
+
+describe('hello', () => {
+  test('returns hello', () => {
+    expect(hello()).toBe('hello')
+  })
+})
+`;
+    writeFileSync(join(pkgDir, 'src', 'index.test.ts'), testTs);
+}
+function createCliPackage(targetDir, projectName) {
+    const pkgDir = join(targetDir, 'packages', 'cli');
+    mkdirSync(join(pkgDir, 'src'), { recursive: true });
+    // package.json
+    const packageJson = {
+        name: `@${projectName}/cli`,
+        version: '0.0.1',
+        type: 'module',
+        bin: {
+            [projectName]: 'dist/cli.js',
+        },
+        files: ['dist'],
+        scripts: {
+            build: 'tsc --build',
+        },
+        dependencies: {
+            [`@${projectName}/core`]: 'workspace:*',
+        },
+    };
+    writeFileSync(join(pkgDir, 'package.json'), `${jsonStringify(packageJson)}\n`);
+    // tsconfig.json
+    const tsConfig = {
+        extends: '../../tsconfig.json',
+        compilerOptions: {
+            composite: true,
+            outDir: 'dist',
+            rootDir: 'src',
+            noEmit: false,
+        },
+        include: ['src/**/*'],
+        references: [{ path: '../core' }],
+    };
+    writeFileSync(join(pkgDir, 'tsconfig.json'), `${jsonStringify(tsConfig)}\n`);
+    // src/cli.ts
+    const cliTs = `#!/usr/bin/env node
+import { hello } from '@${projectName}/core'
+
+console.log(hello())
+`;
+    writeFileSync(join(pkgDir, 'src', 'cli.ts'), cliTs);
+    // src/cli.test.ts
+    const testTs = `import { describe, expect, test } from 'vitest'
+
+describe('cli', () => {
+  test('placeholder test', () => {
+    expect(true).toBe(true)
+  })
+})
+`;
+    writeFileSync(join(pkgDir, 'src', 'cli.test.ts'), testTs);
+}

package/dist/commands/link.d.ts

@@ -0,0 +1,19 @@
+import { type SpawnFn } from '../utils/npm.js';
+export type LinkCommandOptions = {
+    cwd: string;
+    packageName?: string;
+    spawn?: SpawnFn;
+};
+/**
+ * Link a package globally (provider mode) or link from global registry (consumer mode)
+ */
+export declare function link(opts: LinkCommandOptions): Promise<void>;
+/**
+ * Show currently linked packages
+ */
+export declare function linkStatus(opts: Omit<LinkCommandOptions, 'packageName'>): Promise<string>;
+/**
+ * Unlink packages (all or specific)
+ */
+export declare function unlink(opts: LinkCommandOptions): Promise<void>;
+//# sourceMappingURL=link.d.ts.map

package/dist/commands/link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link.d.ts","sourceRoot":"","sources":["../../src/commands/link.ts"],"names":[],"mappings":"AAEA,OAAO,EAA4B,KAAK,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAExE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,GAAG,EAAE,MAAM,CAAA;IACX,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,CAAA;AA0BD;;GAEG;AACH,wBAAsB,IAAI,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CA+BlE;AAED;;GAEG;AACH,wBAAsB,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,kBAAkB,EAAE,aAAa,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAoD/F;AAED;;GAEG;AACH,wBAAsB,MAAM,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAgEpE"}

package/dist/commands/link.js

@@ -0,0 +1,155 @@
+import { existsSync, lstatSync, readdirSync, readFileSync, readlinkSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { defaultSpawn, runOrThrow } from '../utils/npm.js';
+function readPackageJson(cwd) {
+    const pkgPath = join(cwd, 'package.json');
+    if (!existsSync(pkgPath)) {
+        throw new Error(`Missing package.json in ${cwd}`);
+    }
+    const json = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    // Runtime validation: ensure parsed value is an object (not array, primitive, or null)
+    if (typeof json !== 'object' || json === null || Array.isArray(json)) {
+        throw new Error(`Invalid package.json at ${pkgPath}: expected a JSON object`);
+    }
+    return json;
+}
+function hasDistFolder(cwd) {
+    const distPath = join(cwd, 'dist');
+    return existsSync(distPath);
+}
+/**
+ * Link a package globally (provider mode) or link from global registry (consumer mode)
+ */
+export async function link(opts) {
+    const spawn = opts.spawn ?? defaultSpawn;
+    const cwd = resolve(opts.cwd);
+    // Consumer mode: link specific package from global registry
+    if (opts.packageName) {
+        const pkg = readPackageJson(cwd);
+        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (!allDeps[opts.packageName]) {
+            throw new Error(`Package "${opts.packageName}" not found in dependencies or devDependencies of ${cwd}`);
+        }
+        await runOrThrow(spawn, ['pnpm', 'link', '--global', opts.packageName], cwd);
+        console.log(`✓ Linked ${opts.packageName} from global registry`);
+        return;
+    }
+    // Provider mode: link current package globally
+    const pkg = readPackageJson(cwd);
+    if (!pkg.name) {
+        throw new Error(`package.json in ${cwd} is missing a "name" field`);
+    }
+    if (!hasDistFolder(cwd)) {
+        throw new Error(`No dist/ folder in ${cwd}. Run \`proman build\` first.`);
+    }
+    await runOrThrow(spawn, ['pnpm', 'link', '--global'], cwd);
+    console.log(`✓ Linked ${pkg.name} globally`);
+}
+/**
+ * Show currently linked packages
+ */
+export async function linkStatus(opts) {
+    const cwd = resolve(opts.cwd);
+    const nodeModulesDir = join(cwd, 'node_modules');
+    if (!existsSync(nodeModulesDir)) {
+        return 'No linked packages found';
+    }
+    const linkedPackages = [];
+    // Scan node_modules for symlinks
+    function scanDir(dir, prefix = '') {
+        if (!existsSync(dir))
+            return;
+        for (const entry of readdirSync(dir)) {
+            const fullPath = join(dir, entry);
+            const stat = lstatSync(fullPath);
+            // Check if it's a symlink
+            if (stat.isSymbolicLink()) {
+                const target = readlinkSync(fullPath);
+                const resolvedTarget = resolve(dir, target);
+                const pkgJsonPath = join(fullPath, 'package.json');
+                if (existsSync(pkgJsonPath)) {
+                    try {
+                        const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+                        const name = pkgJson.name || `${prefix}${entry}`;
+                        linkedPackages.push({ name, target: resolvedTarget });
+                    }
+                    catch {
+                        // Invalid package.json, skip
+                    }
+                }
+            }
+            else if (stat.isDirectory() && entry.startsWith('@')) {
+                // Scan scoped packages
+                scanDir(fullPath, `${entry}/`);
+            }
+        }
+    }
+    scanDir(nodeModulesDir);
+    if (linkedPackages.length === 0) {
+        return 'No linked packages found';
+    }
+    const lines = ['Linked packages:'];
+    for (const { name, target } of linkedPackages) {
+        lines.push(`• ${name} → ${target}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Unlink packages (all or specific)
+ */
+export async function unlink(opts) {
+    const spawn = opts.spawn ?? defaultSpawn;
+    const cwd = resolve(opts.cwd);
+    // Unlink specific package
+    if (opts.packageName) {
+        await runOrThrow(spawn, ['pnpm', 'unlink', opts.packageName], cwd);
+        await runOrThrow(spawn, ['pnpm', 'install', opts.packageName], cwd);
+        console.log(`✓ Unlinked ${opts.packageName} and restored from registry`);
+        return;
+    }
+    // Unlink all packages
+    const nodeModulesDir = join(cwd, 'node_modules');
+    if (!existsSync(nodeModulesDir)) {
+        console.log('No linked packages to unlink');
+        return;
+    }
+    const linkedPackages = [];
+    // Find all symlinked packages
+    function scanDir(dir) {
+        if (!existsSync(dir))
+            return;
+        for (const entry of readdirSync(dir)) {
+            const fullPath = join(dir, entry);
+            const stat = lstatSync(fullPath);
+            if (stat.isSymbolicLink()) {
+                const pkgJsonPath = join(fullPath, 'package.json');
+                if (existsSync(pkgJsonPath)) {
+                    try {
+                        const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+                        if (pkgJson.name) {
+                            linkedPackages.push(pkgJson.name);
+                        }
+                    }
+                    catch {
+                        // Invalid package.json, skip
+                    }
+                }
+            }
+            else if (stat.isDirectory() && entry.startsWith('@')) {
+                scanDir(fullPath);
+            }
+        }
+    }
+    scanDir(nodeModulesDir);
+    if (linkedPackages.length === 0) {
+        console.log('No linked packages to unlink');
+        return;
+    }
+    // Unlink each package
+    for (const pkgName of linkedPackages) {
+        await runOrThrow(spawn, ['pnpm', 'unlink', pkgName], cwd);
+    }
+    // Restore all packages
+    await runOrThrow(spawn, ['pnpm', 'install'], cwd);
+    console.log(`✓ Unlinked ${linkedPackages.length} package(s) and restored from registry`);
+}

package/dist/commands/publish.d.ts

@@ -0,0 +1,18 @@
+import { type GitOps } from '../utils/git.js';
+import { type NpmRegistryFetch, type NpmRunner, type SpawnFn } from '../utils/npm.js';
+export type { GitOps } from '../utils/git.js';
+export type { NpmRunner } from '../utils/npm.js';
+export type PublishOptions = {
+    skipTests?: boolean;
+    cwd?: string;
+    git?: GitOps;
+    npm?: NpmRunner;
+    registryFetch?: NpmRegistryFetch;
+    spawn?: SpawnFn;
+};
+/**
+ * Publish all packages. Reads each package's version from its own package.json.
+ * build → test → check → smoke test tarball → publish → commit → tag → push
+ */
+export declare function publish(opts?: PublishOptions): Promise<void>;
+//# sourceMappingURL=publish.d.ts.map

package/dist/commands/publish.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish.d.ts","sourceRoot":"","sources":["../../src/commands/publish.ts"],"names":[],"mappings":"AAGA,OAAO,EAAgB,KAAK,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAC3D,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,SAAS,EACd,KAAK,OAAO,EACb,MAAM,iBAAiB,CAAA;AAGxB,YAAY,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAC7C,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAEhD,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,GAAG,CAAC,EAAE,SAAS,CAAA;IACf,aAAa,CAAC,EAAE,gBAAgB,CAAA;IAChC,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB,CAAA;AAoBD;;;GAGG;AACH,wBAAsB,OAAO,CAAC,IAAI,GAAE,cAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAuHtE"}

package/dist/commands/publish.js

@@ -0,0 +1,125 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { loadConfig } from '../config/load-config.js';
+import { createGitOps } from '../utils/git.js';
+import { createNpmRunner, defaultRegistryFetch, defaultSpawn, } from '../utils/npm.js';
+import { smokeTestTarball } from '../utils/smoke-test.js';
+const AUTHOR = '小橘 <xiaoju@shazhou.work>';
+async function readJson(path) {
+    const text = await readFile(path, 'utf8');
+    return JSON.parse(text);
+}
+function isRcVersion(version) {
+    return /-rc\.\d+$/.test(version);
+}
+const ALREADY_PUBLISHED_RE = /cannot publish over the previously published versions|you cannot publish over the previously published version/i;
+function isAlreadyPublished(message) {
+    return ALREADY_PUBLISHED_RE.test(message);
+}
+/**
+ * Publish all packages. Reads each package's version from its own package.json.
+ * build → test → check → smoke test tarball → publish → commit → tag → push
+ */
+export async function publish(opts = {}) {
+    const { skipTests = false } = opts;
+    const cwd = opts.cwd ?? process.cwd();
+    const git = opts.git ?? createGitOps(cwd);
+    const fetchVersions = opts.registryFetch ?? defaultRegistryFetch;
+    const spawn = opts.spawn ?? defaultSpawn;
+    const cfg = loadConfig(cwd);
+    const npm = opts.npm ?? createNpmRunner(cwd);
+    const pkgJsonMap = {};
+    for (const pkg of cfg.packages) {
+        const pkgPath = resolve(cwd, pkg.path, 'package.json');
+        const json = await readJson(pkgPath);
+        const version = json.version;
+        if (!version)
+            throw new Error(`missing version in ${pkgPath}`);
+        pkgJsonMap[pkg.name] = { version, private: json.private === true };
+    }
+    const publishablePackages = cfg.packages.filter((pkg) => pkg.private !== true && pkgJsonMap[pkg.name]?.private !== true);
+    // Read each publishable package's version
+    const versions = {};
+    for (const pkg of publishablePackages) {
+        versions[pkg.name] = pkgJsonMap[pkg.name]?.version;
+    }
+    // Build + test + check
+    await npm.install();
+    await npm.build();
+    console.log('✓ build');
+    if (!skipTests) {
+        await npm.test();
+        console.log('✓ test');
+    }
+    await npm.check();
+    console.log('✓ check');
+    // Log skipped private packages
+    for (const pkg of cfg.packages) {
+        if (pkg.private === true || pkgJsonMap[pkg.name]?.private === true) {
+            console.log(`⏭ skipped ${pkg.name} (private)`);
+        }
+    }
+    // Publish each publishable package
+    const access = cfg.release?.access;
+    for (let i = 0; i < publishablePackages.length; i++) {
+        const entry = publishablePackages[i];
+        const version = versions[entry.name];
+        const isRc = isRcVersion(version);
+        const publishTag = isRc ? 'rc' : 'latest';
+        const pkgDir = resolve(cwd, entry.path);
+        // Pre-check: skip if already published on registry
+        const existingVersions = await fetchVersions(entry.name);
+        if (existingVersions.includes(version)) {
+            console.log(`⏭ skipped ${entry.name}@${version} (already published)`);
+            continue;
+        }
+        // Smoke test: validate tarball before publishing
+        try {
+            await smokeTestTarball(pkgDir, spawn);
+        }
+        catch (err) {
+            const message = err.message;
+            const published = publishablePackages.slice(0, i).map((p) => p.name);
+            const remaining = publishablePackages.slice(i + 1).map((p) => p.name);
+            const msg = `smoke test failed for ${entry.name}: ${message}\n` +
+                `  published: ${published.join(', ') || '(none)'}\n` +
+                `  unpublished: ${[entry.name, ...remaining].join(', ')}`;
+            throw new Error(msg);
+        }
+        try {
+            await npm.publish(pkgDir, { tag: publishTag, ...(access ? { access } : {}) });
+            console.log(`✓ published ${entry.name}@${version}`);
+        }
+        catch (err) {
+            const message = err.message;
+            // Fallback: catch the error in case of race condition
+            if (isAlreadyPublished(message)) {
+                console.log(`⏭ skipped ${entry.name}@${version} (already published)`);
+                continue;
+            }
+            const published = publishablePackages.slice(0, i).map((p) => p.name);
+            const remaining = publishablePackages.slice(i + 1).map((p) => p.name);
+            const msg = `publish failed for ${entry.name}: ${message}\n` +
+                `  published: ${published.join(', ') || '(none)'}\n` +
+                `  unpublished: ${[entry.name, ...remaining].join(', ')}`;
+            throw new Error(msg);
+        }
+    }
+    // Commit + tag + push all publishable packages
+    // Changelog generation and changeset cleanup are now bump's responsibility (issue #74)
+    await git.addAll();
+    const tagPrefix = cfg.release?.gitTagPrefix ?? 'v';
+    const bumpedVersions = Object.entries(versions);
+    const commitVersion = bumpedVersions[0]?.[1] ?? 'unknown';
+    await git.commit(`release: v${commitVersion}`, AUTHOR);
+    for (const [pkgName, version] of bumpedVersions) {
+        const tagName = `${pkgName}@${tagPrefix}${version}`;
+        await git.tag(tagName, `Release ${pkgName}@${version}`);
+    }
+    await git.pushTags();
+    await git.push('main');
+    for (const [pkgName, version] of bumpedVersions) {
+        console.log(`✓ tagged ${pkgName}@${tagPrefix}${version}`);
+    }
+    console.log(`✓ pushed`);
+}

package/dist/config/index.d.ts

@@ -0,0 +1,4 @@
+export { loadConfig } from './load-config.js';
+export type { PackageEntry, PackageType, PromanConfig, ReleaseConfig, } from './types.js';
+export { validateConfig } from './validate-config.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,YAAY,EACV,YAAY,EACZ,WAAW,EACX,YAAY,EACZ,aAAa,GACd,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA"}

package/dist/config/index.js

@@ -0,0 +1,2 @@
+export { loadConfig } from './load-config.js';
+export { validateConfig } from './validate-config.js';

package/dist/config/load-config.d.ts

@@ -0,0 +1,6 @@
+import type { PromanConfig } from './types.js';
+/**
+ * Loads `proman.yaml` from the given cwd (or `process.cwd()`).
+ */
+export declare function loadConfig(cwd?: string): PromanConfig;
+//# sourceMappingURL=load-config.d.ts.map

package/dist/config/load-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-config.d.ts","sourceRoot":"","sources":["../../src/config/load-config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAiB,MAAM,YAAY,CAAA;AAiB7D;;GAEG;AACH,wBAAgB,UAAU,CAAC,GAAG,GAAE,MAAsB,GAAG,YAAY,CASpE"}

package/dist/config/load-config.js

@@ -0,0 +1,29 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { parse } from 'yaml';
+import { validateConfig } from './validate-config.js';
+const DEFAULT_REGISTRY = 'https://registry.npmjs.org';
+const DEFAULT_GIT_TAG_PREFIX = 'v';
+function applyDefaults(config) {
+    const release = {
+        registry: config.release?.registry ?? DEFAULT_REGISTRY,
+        gitTagPrefix: config.release?.gitTagPrefix ?? DEFAULT_GIT_TAG_PREFIX,
+    };
+    if (config.release?.access !== undefined) {
+        release.access = config.release.access;
+    }
+    return { ...config, release };
+}
+/**
+ * Loads `proman.yaml` from the given cwd (or `process.cwd()`).
+ */
+export function loadConfig(cwd = process.cwd()) {
+    const absPath = resolve(cwd, 'proman.yaml');
+    if (!existsSync(absPath)) {
+        throw new Error(`proman.yaml not found at ${absPath}`);
+    }
+    const text = readFileSync(absPath, 'utf8');
+    const raw = parse(text);
+    const validated = validateConfig(raw);
+    return applyDefaults(validated);
+}

package/dist/config/types.d.ts

@@ -0,0 +1,17 @@
+export type PackageType = 'lib' | 'cli' | 'webui' | 'api';
+export type PackageEntry = {
+    name: string;
+    path: string;
+    type: PackageType;
+    private?: boolean;
+};
+export type ReleaseConfig = {
+    registry?: string;
+    access?: 'public' | 'restricted';
+    gitTagPrefix?: string;
+};
+export type PromanConfig = {
+    packages: PackageEntry[];
+    release?: ReleaseConfig;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/config/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/config/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,GAAG,KAAK,CAAA;AAEzD,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,WAAW,CAAA;IACjB,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,QAAQ,GAAG,YAAY,CAAA;IAChC,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,EAAE,YAAY,EAAE,CAAA;IACxB,OAAO,CAAC,EAAE,aAAa,CAAA;CACxB,CAAA"}

package/dist/config/types.js

@@ -0,0 +1 @@
+export {};

package/dist/config/validate-config.d.ts

@@ -0,0 +1,7 @@
+import type { PromanConfig } from './types.js';
+/**
+ * Pure validator. Throws Error with descriptive message on failure.
+ * Returns a typed PromanConfig (does not mutate input, does not apply defaults).
+ */
+export declare function validateConfig(value: unknown): PromanConfig;
+//# sourceMappingURL=validate-config.d.ts.map