@treeseed/cli 0.1.1 → 0.4.0

package/dist/scripts/workspace-lint.d.ts

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

package/dist/scripts/workspace-lint.js

@@ -1,9 +0,0 @@
-import { packageScriptPath } from './package-tools.js';
-import { packagesWithScript, run, workspaceRoot } from './workspace-tools.js';
-const root = workspaceRoot();
-run(process.execPath, [packageScriptPath('cleanup-markdown'), '--check'], {
-    cwd: root,
-});
-for (const pkg of packagesWithScript('lint', root)) {
-    run('npm', ['run', 'lint'], { cwd: pkg.dir });
-}

package/dist/scripts/workspace-preflight-lib.d.ts

@@ -1,36 +0,0 @@
-export declare function createWranglerCommandEnv(overrides?: {}): {
-    XDG_CONFIG_HOME: string;
-    WRANGLER_SEND_METRICS: string;
-};
-export declare function parseGitHubAuthStatus(output: any, status: any): {
-    authenticated: boolean;
-    detail: any;
-};
-export declare function parseWranglerWhoAmI(output: any, status: any): {
-    authenticated: boolean;
-    detail: any;
-};
-export declare function parseCopilotSessionStatus(output: any, status: any): {
-    configured: boolean;
-    detail: any;
-};
-export declare function collectCliPreflight({ cwd, requireAuth }?: {
-    cwd?: string | undefined;
-    requireAuth?: boolean | undefined;
-}): {
-    ok: boolean;
-    requireAuth: boolean;
-    missingCommands: string[];
-    failingAuth: string[];
-    checks: {
-        commands: {
-            [k: string]: {
-                installed: boolean;
-                path: string | null;
-            };
-        };
-        auth: {};
-    };
-};
-export declare function formatCliPreflightReport(report: any): string;
-export declare function writeJsonArtifact(filePath: any, value: any): void;

package/dist/scripts/workspace-preflight-lib.js

@@ -1,179 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { spawnSync } from 'node:child_process';
-import { tmpdir } from 'node:os';
-import { dirname, resolve } from 'node:path';
-import { createTempDir } from './workspace-tools.js';
-function runCapture(command, args, options = {}) {
-    const result = spawnSync(command, args, {
-        cwd: options.cwd ?? process.cwd(),
-        env: { ...process.env, ...(options.env ?? {}) },
-        stdio: 'pipe',
-        encoding: 'utf8',
-        timeout: options.timeoutMs,
-    });
-    return {
-        status: result.status ?? 1,
-        signal: result.signal ?? null,
-        stdout: result.stdout ?? '',
-        stderr: result.stderr ?? '',
-        error: result.error?.message ?? null,
-    };
-}
-function locateBinary(candidate) {
-    const result = runCapture('bash', ['-lc', `command -v ${candidate}`]);
-    return result.status === 0 ? result.stdout.trim() : null;
-}
-export function createWranglerCommandEnv(overrides = {}) {
-    const configHome = createTempDir('treeseed-wrangler-config-');
-    const logDir = resolve(configHome, '.wrangler', 'logs');
-    mkdirSync(logDir, { recursive: true });
-    return {
-        XDG_CONFIG_HOME: configHome,
-        WRANGLER_SEND_METRICS: 'false',
-        ...overrides,
-    };
-}
-export function parseGitHubAuthStatus(output, status) {
-    return {
-        authenticated: status === 0 && /Logged in|Active account:/i.test(output),
-        detail: output.trim(),
-    };
-}
-export function parseWranglerWhoAmI(output, status) {
-    return {
-        authenticated: status === 0 && !/error|failed/i.test(output),
-        detail: output.trim(),
-    };
-}
-export function parseCopilotSessionStatus(output, status) {
-    const normalized = output.trim();
-    return {
-        configured: status === 0 || /copilot_github_token|github_token|gh_token/i.test(normalized),
-        detail: normalized,
-    };
-}
-function copilotSessionProbe() {
-    const configDir = process.env.COPILOT_CONFIG_DIR
-        ? resolve(process.env.COPILOT_CONFIG_DIR)
-        : resolve(process.env.HOME ?? tmpdir(), '.copilot');
-    const authPath = resolve(configDir, 'auth.json');
-    const envConfigured = ['COPILOT_GITHUB_TOKEN', 'GH_TOKEN', 'GITHUB_TOKEN'].some((key) => {
-        const value = process.env[key];
-        return typeof value === 'string' && value.length > 0;
-    });
-    if (envConfigured) {
-        return {
-            status: 0,
-            output: 'Copilot token environment variable detected.',
-        };
-    }
-    if (!existsSync(authPath)) {
-        return {
-            status: 1,
-            output: `No Copilot token environment variable detected and ${authPath} was not found.`,
-        };
-    }
-    try {
-        const contents = readFileSync(authPath, 'utf8');
-        if (contents.trim().length === 0) {
-            return {
-                status: 1,
-                output: `${authPath} is empty.`,
-            };
-        }
-        return {
-            status: 0,
-            output: `Copilot auth configuration detected at ${authPath}.`,
-        };
-    }
-    catch (error) {
-        return {
-            status: 1,
-            output: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-export function collectCliPreflight({ cwd = process.cwd(), requireAuth = false } = {}) {
-    const binaries = {
-        git: locateBinary('git'),
-        npm: locateBinary('npm'),
-        gh: locateBinary('gh'),
-        wrangler: locateBinary('wrangler'),
-        copilot: locateBinary('copilot'),
-    };
-    const checks = {
-        commands: Object.fromEntries(Object.entries(binaries).map(([name, path]) => [name, {
-                installed: Boolean(path),
-                path,
-            }])),
-        auth: {},
-    };
-    if (binaries.gh) {
-        const result = runCapture('gh', ['auth', 'status'], { cwd });
-        checks.auth.gh = parseGitHubAuthStatus(`${result.stdout}\n${result.stderr}`.trim(), result.status);
-    }
-    else {
-        checks.auth.gh = { authenticated: false, detail: 'GitHub CLI is not installed.' };
-    }
-    if (binaries.wrangler) {
-        const env = createWranglerCommandEnv();
-        const result = runCapture('wrangler', ['whoami'], { cwd, env, timeoutMs: 60000 });
-        checks.auth.wrangler = parseWranglerWhoAmI(`${result.stdout}\n${result.stderr}`.trim(), result.status);
-    }
-    else {
-        checks.auth.wrangler = { authenticated: false, detail: 'Wrangler CLI is not installed.' };
-    }
-    if (binaries.copilot) {
-        const probe = copilotSessionProbe();
-        checks.auth.copilot = parseCopilotSessionStatus(probe.output, probe.status);
-    }
-    else {
-        checks.auth.copilot = { configured: false, detail: 'Copilot CLI is not installed.' };
-    }
-    const missingCommands = Object.entries(checks.commands)
-        .filter(([, value]) => !value.installed)
-        .map(([name]) => name);
-    const failingAuth = [];
-    if (requireAuth) {
-        if (!checks.auth.gh?.authenticated)
-            failingAuth.push('gh');
-        if (!checks.auth.wrangler?.authenticated)
-            failingAuth.push('wrangler');
-    }
-    return {
-        ok: missingCommands.length === 0 && failingAuth.length === 0,
-        requireAuth,
-        missingCommands,
-        failingAuth,
-        checks,
-    };
-}
-export function formatCliPreflightReport(report) {
-    const lines = [
-        'Treeseed preflight summary',
-        `Status: ${report.ok ? 'ok' : 'failed'}`,
-        `Require auth: ${report.requireAuth ? 'yes' : 'no'}`,
-        'Commands:',
-    ];
-    for (const [name, info] of Object.entries(report.checks.commands)) {
-        lines.push(`- ${name}: ${info.installed ? `installed (${info.path})` : 'missing'}`);
-    }
-    lines.push('Auth/session:');
-    lines.push(`- gh: ${report.checks.auth.gh?.authenticated ? 'authenticated' : 'not authenticated'}`);
-    lines.push(`  ${report.checks.auth.gh?.detail ?? ''}`.trimEnd());
-    lines.push(`- wrangler: ${report.checks.auth.wrangler?.authenticated ? 'authenticated' : 'not authenticated'}`);
-    lines.push(`  ${report.checks.auth.wrangler?.detail ?? ''}`.trimEnd());
-    lines.push(`- copilot: ${report.checks.auth.copilot?.configured ? 'configured' : 'not configured'}`);
-    lines.push(`  ${report.checks.auth.copilot?.detail ?? ''}`.trimEnd());
-    if (report.missingCommands.length > 0) {
-        lines.push(`Missing commands: ${report.missingCommands.join(', ')}`);
-    }
-    if (report.failingAuth.length > 0) {
-        lines.push(`Auth failures: ${report.failingAuth.join(', ')}`);
-    }
-    return lines.filter(Boolean).join('\n');
-}
-export function writeJsonArtifact(filePath, value) {
-    mkdirSync(dirname(filePath), { recursive: true });
-    writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
-}

package/dist/scripts/workspace-preflight.d.ts

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

package/dist/scripts/workspace-preflight.js

@@ -1,22 +0,0 @@
-#!/usr/bin/env node
-import { resolve } from 'node:path';
-import { collectCliPreflight, formatCliPreflightReport, writeJsonArtifact } from './workspace-preflight-lib.js';
-const args = new Set(process.argv.slice(2));
-const requireAuth = args.has('--require-auth');
-const json = args.has('--json');
-const reportPathArgIndex = process.argv.indexOf('--report-path');
-const reportPath = reportPathArgIndex >= 0 ? process.argv[reportPathArgIndex + 1] : process.env.TREESEED_PREFLIGHT_REPORT_PATH;
-const report = collectCliPreflight({
-    cwd: process.cwd(),
-    requireAuth,
-});
-if (reportPath) {
-    writeJsonArtifact(resolve(reportPath), report);
-}
-if (json) {
-    console.log(JSON.stringify(report, null, 2));
-}
-else {
-    console.log(formatCliPreflightReport(report));
-}
-process.exit(report.ok ? 0 : 1);

package/dist/scripts/workspace-publish-changed-packages.d.ts

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

package/dist/scripts/workspace-publish-changed-packages.js

@@ -1,16 +0,0 @@
-import { packageScriptPath } from './package-tools.js';
-import { publishableWorkspacePackages, changedWorkspacePackages, run } from './workspace-tools.js';
-const publishablePackages = publishableWorkspacePackages();
-const changed = changedWorkspacePackages({ packages: publishablePackages, includeDependents: true });
-if (changed.length === 0) {
-    console.log('No changed workspace packages to publish.');
-    process.exit(0);
-}
-console.log(`Publishing changed workspace packages in order: ${changed.map((pkg) => pkg.name).join(', ')}`);
-run(process.execPath, [packageScriptPath('workspace-release-verify'), '--changed', '--full-smoke']);
-for (const pkg of changed) {
-    console.log(`Publishing ${pkg.name}`);
-    run('npm', ['run', 'release:publish'], {
-        cwd: pkg.dir,
-    });
-}

package/dist/scripts/workspace-release-verify.d.ts

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

package/dist/scripts/workspace-release-verify.js

@@ -1,81 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { publishableWorkspacePackages, changedWorkspacePackages, } from './workspace-tools.js';
-const cliArgs = new Set(process.argv.slice(2));
-const verifyChangedOnly = cliArgs.has('--changed');
-const fullSmoke = cliArgs.has('--full-smoke') || process.env.TREESEED_RELEASE_FULL_SMOKE === '1';
-const publishablePackages = publishableWorkspacePackages();
-const packagesToVerify = verifyChangedOnly
-    ? changedWorkspacePackages({ packages: publishablePackages, includeDependents: true })
-    : publishablePackages;
-const timings = [];
-function nowLabel() {
-    return new Date().toISOString();
-}
-function logStep(message) {
-    console.log(`[release-verify ${nowLabel()}] ${message}`);
-}
-async function withTiming(label, action) {
-    const startedAt = Date.now();
-    logStep(`${label} started`);
-    try {
-        await action();
-        const durationMs = Date.now() - startedAt;
-        timings.push({ label, durationMs, status: 'completed' });
-        logStep(`${label} completed in ${(durationMs / 1000).toFixed(1)}s`);
-    }
-    catch (error) {
-        const durationMs = Date.now() - startedAt;
-        timings.push({ label, durationMs, status: 'failed' });
-        logStep(`${label} failed in ${(durationMs / 1000).toFixed(1)}s`);
-        throw error;
-    }
-}
-function printSummary() {
-    if (timings.length === 0) {
-        return;
-    }
-    console.log('[release-verify] Stage summary');
-    for (const entry of timings) {
-        console.log(`[release-verify] ${entry.status === 'completed' ? 'ok  ' : 'fail'} ${entry.label} (${(entry.durationMs / 1000).toFixed(1)}s)`);
-    }
-}
-function verifyManifest(pkg) {
-    for (const [dep, value] of Object.entries(pkg.packageJson.dependencies ?? {})) {
-        if (!dep.startsWith('@treeseed/')) {
-            continue;
-        }
-        if (String(value).startsWith('file:') || String(value).startsWith('workspace:')) {
-            throw new Error(`${pkg.name} dependency ${dep} must not use local-only specifier "${value}".`);
-        }
-    }
-}
-function runReleaseVerify(pkg) {
-    const extraArgs = fullSmoke ? ['--', '--full-smoke'] : [];
-    const result = spawnSync('npm', ['run', 'release:verify', ...extraArgs], {
-        cwd: pkg.dir,
-        stdio: 'inherit',
-        env: process.env,
-    });
-    if (result.status !== 0) {
-        throw new Error(`${pkg.name} release:verify failed`);
-    }
-}
-if (packagesToVerify.length === 0) {
-    console.log('No changed workspace packages to verify.');
-    process.exit(0);
-}
-try {
-    logStep(`verifying ${packagesToVerify.map((pkg) => pkg.name).join(', ')} with package-owned ${fullSmoke ? 'full' : 'fast'} verification`);
-    for (const pkg of packagesToVerify) {
-        await withTiming(`${pkg.name} manifest verification`, async () => {
-            verifyManifest(pkg);
-        });
-        await withTiming(`${pkg.name} release:verify`, async () => {
-            runReleaseVerify(pkg);
-        });
-    }
-    console.log(`Release verification passed for: ${packagesToVerify.map((pkg) => pkg.name).join(', ')}`);
-}
-finally {
-    printSummary();
-}

package/dist/scripts/workspace-release.d.ts

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

package/dist/scripts/workspace-release.js

@@ -1,42 +0,0 @@
-#!/usr/bin/env node
-import { readFileSync, writeFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { applyTreeseedEnvironmentToProcess } from './config-runtime-lib.js';
-import { PRODUCTION_BRANCH, STAGING_BRANCH, mergeStagingIntoMain, prepareReleaseBranches, pushBranch } from './git-workflow-lib.js';
-import { incrementVersion, planWorkspaceReleaseBump, applyWorkspaceVersionChanges, repoRoot } from './workspace-save-lib.js';
-import { run, workspaceRoot } from './workspace-tools.js';
-import { runWorkspaceSavePreflight } from './save-deploy-preflight-lib.js';
-function parseArgs(argv) {
-    const flags = new Set(argv);
-    const selected = ['major', 'minor', 'patch'].filter((level) => flags.has(`--${level}`));
-    if (selected.length !== 1) {
-        throw new Error('Treeseed release requires exactly one version bump flag: --major, --minor, or --patch.');
-    }
-    return { level: selected[0] };
-}
-function bumpRootPackageJson(root, level) {
-    const packageJsonPath = resolve(root, 'package.json');
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-    packageJson.version = incrementVersion(packageJson.version, level);
-    writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, 'utf8');
-    return packageJson.version;
-}
-const { level } = parseArgs(process.argv.slice(2));
-const root = workspaceRoot();
-const gitRoot = repoRoot(root);
-prepareReleaseBranches(root);
-applyTreeseedEnvironmentToProcess({ tenantRoot: root, scope: 'staging' });
-runWorkspaceSavePreflight({ cwd: root });
-const plan = planWorkspaceReleaseBump(level, root);
-applyWorkspaceVersionChanges(plan);
-const rootVersion = bumpRootPackageJson(root, level);
-run('git', ['checkout', STAGING_BRANCH], { cwd: gitRoot });
-run('git', ['add', '-A'], { cwd: gitRoot });
-run('git', ['commit', '-m', `release: ${level} bump`], { cwd: gitRoot });
-pushBranch(gitRoot, STAGING_BRANCH);
-mergeStagingIntoMain(root);
-console.log('Treeseed release completed successfully.');
-console.log(`Staging branch: ${STAGING_BRANCH}`);
-console.log(`Production branch: ${PRODUCTION_BRANCH}`);
-console.log(`Release level: ${level}`);
-console.log(`Root version: ${rootVersion}`);

package/dist/scripts/workspace-save-lib.d.ts

@@ -1,42 +0,0 @@
-export declare const MERGE_CONFLICT_EXIT_CODE = 12;
-export declare function incrementPatchVersion(version: any): string;
-export declare function incrementVersion(version: any, level?: string): string;
-export declare function planWorkspaceVersionChanges(root?: string): {
-    packages: any[];
-    publishable: Set<any>;
-    bumped: Set<any>;
-    touched: Set<unknown>;
-};
-export declare function applyWorkspaceVersionChanges(plan: any): any;
-export declare function planWorkspaceReleaseBump(level?: string, root?: string): {
-    packages: any[];
-    touched: Set<unknown>;
-    versions: Map<any, any>;
-    level: string;
-};
-export declare function repoRoot(cwd?: string): string;
-export declare function currentBranch(repoDir: any): string;
-export declare function originRemoteUrl(repoDir: any): string;
-export declare function gitStatusPorcelain(repoDir: any): string;
-export declare function hasMeaningfulChanges(repoDir: any): boolean;
-export declare function countConflictMarkers(source: any): {
-    start: any;
-    middle: any;
-    end: any;
-};
-export declare function collectMergeConflictReport(repoDir: any): {
-    branch: string;
-    rebaseInProgress: boolean;
-    conflictedFiles: string[];
-    status: string;
-    perFile: {
-        filePath: string;
-        markers: {
-            start: any;
-            middle: any;
-            end: any;
-        };
-        diff: string;
-    }[];
-};
-export declare function formatMergeConflictReport(report: any, repoDir: any, targetBranch?: string): string;

package/dist/scripts/workspace-save-lib.js

@@ -1,220 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { changedWorkspacePackages, publishableWorkspacePackages, run, sortWorkspacePackages, workspacePackages, workspaceRoot } from './workspace-tools.js';
-export const MERGE_CONFLICT_EXIT_CODE = 12;
-function parseSemver(version) {
-    const match = String(version).trim().match(/^(\d+)\.(\d+)\.(\d+)$/);
-    if (!match) {
-        throw new Error(`Unsupported version "${version}". Expected x.y.z.`);
-    }
-    return {
-        major: Number(match[1]),
-        minor: Number(match[2]),
-        patch: Number(match[3]),
-    };
-}
-export function incrementPatchVersion(version) {
-    const parsed = parseSemver(version);
-    return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}`;
-}
-export function incrementVersion(version, level = 'patch') {
-    const parsed = parseSemver(version);
-    if (level === 'major') {
-        return `${parsed.major + 1}.0.0`;
-    }
-    if (level === 'minor') {
-        return `${parsed.major}.${parsed.minor + 1}.0`;
-    }
-    if (level === 'patch') {
-        return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}`;
-    }
-    throw new Error(`Unsupported release bump "${level}". Expected major, minor, or patch.`);
-}
-function readPackageJson(filePath) {
-    return JSON.parse(readFileSync(filePath, 'utf8'));
-}
-function writePackageJson(filePath, value) {
-    writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
-}
-function internalDependencyFields(packageJson) {
-    return ['dependencies', 'optionalDependencies', 'peerDependencies', 'devDependencies']
-        .filter((field) => packageJson[field] && typeof packageJson[field] === 'object');
-}
-export function planWorkspaceVersionChanges(root = workspaceRoot()) {
-    const packages = workspacePackages(root).map((pkg) => ({
-        ...pkg,
-        packageJsonPath: resolve(pkg.dir, 'package.json'),
-        packageJson: readPackageJson(resolve(pkg.dir, 'package.json')),
-    }));
-    const orderedPackages = sortWorkspacePackages(packages);
-    const publishable = new Set(publishableWorkspacePackages(root).map((pkg) => pkg.name));
-    const changedPublishable = new Set(changedWorkspacePackages({
-        root,
-        packages: orderedPackages.filter((pkg) => publishable.has(pkg.name)),
-        includeDependents: false,
-    }).map((pkg) => pkg.name));
-    const versions = new Map(orderedPackages.map((pkg) => [pkg.name, pkg.packageJson.version]));
-    const bumped = new Set(changedPublishable);
-    const touched = new Set();
-    for (const name of changedPublishable) {
-        versions.set(name, incrementPatchVersion(versions.get(name)));
-    }
-    let changed = true;
-    while (changed) {
-        changed = false;
-        for (const pkg of orderedPackages) {
-            let packageDependencyChanged = false;
-            for (const field of internalDependencyFields(pkg.packageJson)) {
-                for (const depName of Object.keys(pkg.packageJson[field] ?? {})) {
-                    if (!versions.has(depName)) {
-                        continue;
-                    }
-                    const nextSpec = `^${versions.get(depName)}`;
-                    if (pkg.packageJson[field][depName] === nextSpec) {
-                        continue;
-                    }
-                    pkg.packageJson[field][depName] = nextSpec;
-                    packageDependencyChanged = true;
-                    touched.add(pkg.name);
-                }
-            }
-            if (packageDependencyChanged && publishable.has(pkg.name) && !bumped.has(pkg.name)) {
-                bumped.add(pkg.name);
-                versions.set(pkg.name, incrementPatchVersion(versions.get(pkg.name)));
-                changed = true;
-            }
-        }
-    }
-    for (const pkg of orderedPackages) {
-        if (!bumped.has(pkg.name)) {
-            continue;
-        }
-        const nextVersion = versions.get(pkg.name);
-        if (pkg.packageJson.version !== nextVersion) {
-            pkg.packageJson.version = nextVersion;
-            touched.add(pkg.name);
-        }
-    }
-    return {
-        packages: orderedPackages,
-        publishable,
-        bumped,
-        touched,
-    };
-}
-export function applyWorkspaceVersionChanges(plan) {
-    for (const pkg of plan.packages) {
-        if (!plan.touched.has(pkg.name)) {
-            continue;
-        }
-        writePackageJson(pkg.packageJsonPath, pkg.packageJson);
-    }
-    return plan;
-}
-export function planWorkspaceReleaseBump(level = 'patch', root = workspaceRoot()) {
-    const packages = workspacePackages(root).map((pkg) => ({
-        ...pkg,
-        packageJsonPath: resolve(pkg.dir, 'package.json'),
-        packageJson: readPackageJson(resolve(pkg.dir, 'package.json')),
-    }));
-    const publishable = new Set(publishableWorkspacePackages(root).map((pkg) => pkg.name));
-    const touched = new Set();
-    const versions = new Map();
-    for (const pkg of packages) {
-        if (!publishable.has(pkg.name)) {
-            continue;
-        }
-        const nextVersion = incrementVersion(pkg.packageJson.version, level);
-        pkg.packageJson.version = nextVersion;
-        versions.set(pkg.name, nextVersion);
-        touched.add(pkg.name);
-    }
-    for (const pkg of packages) {
-        for (const field of internalDependencyFields(pkg.packageJson)) {
-            for (const depName of Object.keys(pkg.packageJson[field] ?? {})) {
-                if (!versions.has(depName)) {
-                    continue;
-                }
-                pkg.packageJson[field][depName] = `^${versions.get(depName)}`;
-                touched.add(pkg.name);
-            }
-        }
-    }
-    return {
-        packages,
-        touched,
-        versions,
-        level,
-    };
-}
-export function repoRoot(cwd = workspaceRoot()) {
-    return run('git', ['rev-parse', '--show-toplevel'], { cwd, capture: true }).trim();
-}
-export function currentBranch(repoDir) {
-    return run('git', ['branch', '--show-current'], { cwd: repoDir, capture: true }).trim();
-}
-export function originRemoteUrl(repoDir) {
-    return run('git', ['remote', 'get-url', 'origin'], { cwd: repoDir, capture: true }).trim();
-}
-export function gitStatusPorcelain(repoDir) {
-    return run('git', ['status', '--porcelain'], { cwd: repoDir, capture: true }).trim();
-}
-export function hasMeaningfulChanges(repoDir) {
-    return gitStatusPorcelain(repoDir).length > 0;
-}
-export function countConflictMarkers(source) {
-    return {
-        start: (source.match(/^<{7} /gm) ?? []).length,
-        middle: (source.match(/^={7}$/gm) ?? []).length,
-        end: (source.match(/^>{7} /gm) ?? []).length,
-    };
-}
-export function collectMergeConflictReport(repoDir) {
-    const branch = currentBranch(repoDir);
-    const conflictedFiles = run('git', ['diff', '--name-only', '--diff-filter=U'], {
-        cwd: repoDir,
-        capture: true,
-    })
-        .split('\n')
-        .map((line) => line.trim())
-        .filter(Boolean);
-    const status = run('git', ['status', '--short'], { cwd: repoDir, capture: true });
-    const perFile = conflictedFiles.map((filePath) => {
-        const fullPath = resolve(repoDir, filePath);
-        const source = existsSync(fullPath) ? readFileSync(fullPath, 'utf8') : '';
-        return {
-            filePath,
-            markers: countConflictMarkers(source),
-            diff: run('git', ['diff', '--', filePath], { cwd: repoDir, capture: true }),
-        };
-    });
-    return {
-        branch,
-        rebaseInProgress: true,
-        conflictedFiles,
-        status,
-        perFile,
-    };
-}
-export function formatMergeConflictReport(report, repoDir, targetBranch = 'main') {
-    const lines = [
-        `Treeseed save failed due to merge conflicts during \`git pull --rebase origin ${targetBranch}\`.`,
-        `Repository root: ${repoDir}`,
-        `Branch: ${report.branch}`,
-        `Rebase in progress: ${report.rebaseInProgress ? 'yes' : 'no'}`,
-        'Git status:',
-        report.status || '(no git status output)',
-        'Conflicted files:',
-    ];
-    for (const file of report.perFile) {
-        lines.push(`- ${file.filePath}`);
-        lines.push(`  markers: start=${file.markers.start} middle=${file.markers.middle} end=${file.markers.end}`);
-        lines.push('  diff:');
-        lines.push(file.diff || '  (no diff output)');
-    }
-    lines.push('Next steps:');
-    lines.push('- Inspect conflicted files and reconcile local vs remote changes.');
-    lines.push('- After resolving files, run `git add <files>` and `git rebase --continue`.');
-    lines.push('- Or abort with `git rebase --abort` if you need to restart the save flow.');
-    return lines.join('\n');
-}

package/dist/scripts/workspace-save.d.ts

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