@treeseed/cli 0.1.1 → 0.4.2

package/dist/scripts/workspace-save.js

@@ -1,124 +0,0 @@
-#!/usr/bin/env node
-import { writeFileSync, mkdirSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { applyTreeseedEnvironmentToProcess } from './config-runtime-lib.js';
-import { collectMergeConflictReport, currentBranch, formatMergeConflictReport, hasMeaningfulChanges, originRemoteUrl, repoRoot, } from './workspace-save-lib.js';
-import { remoteBranchExists, STAGING_BRANCH, PRODUCTION_BRANCH } from './git-workflow-lib.js';
-import { run, workspaceRoot } from './workspace-tools.js';
-import { runWorkspaceSavePreflight } from './save-deploy-preflight-lib.js';
-function writeSaveReport(payload) {
-    const target = process.env.TREESEED_SAVE_REPORT_PATH;
-    if (!target) {
-        return;
-    }
-    const filePath = resolve(target);
-    mkdirSync(dirname(filePath), { recursive: true });
-    writeFileSync(filePath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
-}
-function parseArgs(argv) {
-    const parsed = {
-        hotfix: false,
-        messageParts: [],
-    };
-    for (const current of argv) {
-        if (current === '--hotfix') {
-            parsed.hotfix = true;
-            continue;
-        }
-        parsed.messageParts.push(current);
-    }
-    return {
-        hotfix: parsed.hotfix,
-        message: parsed.messageParts.join(' ').trim(),
-    };
-}
-const options = parseArgs(process.argv.slice(2));
-const message = options.message;
-const root = workspaceRoot();
-const gitRoot = repoRoot(root);
-const branch = currentBranch(gitRoot);
-const scope = branch === STAGING_BRANCH ? 'staging' : branch === PRODUCTION_BRANCH ? 'prod' : 'local';
-applyTreeseedEnvironmentToProcess({ tenantRoot: root, scope });
-if (!message) {
-    writeSaveReport({ ok: false, kind: 'usage', message: 'Treeseed save requires a commit message.' });
-    console.error('Treeseed save requires a commit message. Usage: treeseed save <message>');
-    process.exit(1);
-}
-if (!branch) {
-    writeSaveReport({ ok: false, kind: 'missing_branch', message: 'Treeseed save requires an active git branch.' });
-    console.error('Treeseed save requires an active git branch.');
-    process.exit(1);
-}
-if (branch === PRODUCTION_BRANCH && !options.hotfix) {
-    writeSaveReport({
-        ok: false,
-        kind: 'protected_branch',
-        branch,
-        message: 'Treeseed save is blocked on main. Use `treeseed release` for normal production promotion or `treeseed save --hotfix` for an explicit hotfix.',
-    });
-    console.error('Treeseed save is blocked on main. Use `treeseed release` for normal production promotion or `treeseed save --hotfix` for an explicit hotfix.');
-    process.exit(1);
-}
-try {
-    originRemoteUrl(gitRoot);
-}
-catch {
-    writeSaveReport({ ok: false, kind: 'missing_origin', message: 'Treeseed save requires an origin remote.' });
-    console.error('Treeseed save requires an origin remote.');
-    process.exit(1);
-}
-try {
-    runWorkspaceSavePreflight({ cwd: root });
-}
-catch (error) {
-    const kind = error?.kind ?? 'preflight_failed';
-    writeSaveReport({
-        ok: false,
-        kind,
-        message: error instanceof Error ? error.message : String(error),
-    });
-    console.error(error instanceof Error ? error.message : String(error));
-    process.exit(error?.exitCode ?? 1);
-}
-if (!hasMeaningfulChanges(gitRoot)) {
-    writeSaveReport({ ok: false, kind: 'no_changes', message: 'Treeseed save found no meaningful repository changes to commit.' });
-    console.error('Treeseed save found no meaningful repository changes to commit.');
-    process.exit(1);
-}
-run('git', ['add', '-A'], { cwd: gitRoot });
-run('git', ['commit', '-m', message], { cwd: gitRoot });
-try {
-    if (remoteBranchExists(gitRoot, branch)) {
-        run('git', ['pull', '--rebase', 'origin', branch], { cwd: gitRoot });
-        run('git', ['push', 'origin', branch], { cwd: gitRoot });
-    }
-    else {
-        run('git', ['push', '-u', 'origin', branch], { cwd: gitRoot });
-    }
-}
-catch (error) {
-    const report = collectMergeConflictReport(gitRoot);
-    writeSaveReport({
-        ok: false,
-        kind: 'merge_conflict',
-        branch,
-        report,
-        formatted: formatMergeConflictReport(report, gitRoot, branch),
-    });
-    console.error(formatMergeConflictReport(report, gitRoot, branch));
-    process.exit(12);
-}
-const summary = {
-    ok: true,
-    kind: 'success',
-    message,
-    branch,
-    scope,
-    hotfix: options.hotfix,
-    root,
-    repositoryRoot: gitRoot,
-};
-writeSaveReport(summary);
-console.log('Treeseed save completed successfully.');
-console.log(`Branch: ${branch}`);
-console.log(`Environment scope: ${scope}`);

package/dist/scripts/workspace-start-warning.js

@@ -1,3 +0,0 @@
-console.error('`npm run start` is deprecated because `treeseed start` creates feature branches.');
-console.error('Use `treeseed dev` for local development or `treeseed start <branch-name>` for branch creation.');
-process.exit(1);

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

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

package/dist/scripts/workspace-start.js

@@ -1,71 +0,0 @@
-#!/usr/bin/env node
-import { spawnSync } from 'node:child_process';
-import { applyTreeseedEnvironmentToProcess, assertTreeseedCommandEnvironment } from './config-runtime-lib.js';
-import { createBranchPreviewDeployTarget, deployTargetLabel, ensureGeneratedWranglerConfig, finalizeDeploymentState, printDeploySummary, provisionCloudflareResources, runRemoteD1Migrations, syncCloudflareSecrets, validateDeployPrerequisites, } from './deploy-lib.js';
-import { createFeatureBranchFromStaging, pushBranch } from './git-workflow-lib.js';
-import { packageScriptPath, resolveWranglerBin } from './package-tools.js';
-function parseArgs(argv) {
-    const parsed = {
-        branchName: null,
-        preview: false,
-    };
-    for (const current of argv) {
-        if (current === '--preview') {
-            parsed.preview = true;
-            continue;
-        }
-        if (!parsed.branchName) {
-            parsed.branchName = current;
-            continue;
-        }
-        throw new Error(`Unknown start argument: ${current}`);
-    }
-    if (!parsed.branchName) {
-        throw new Error('Usage: treeseed start <branch-name> [--preview]');
-    }
-    return parsed;
-}
-function runNodeScript(scriptPath, scriptArgs = [], cwd) {
-    const result = spawnSync(process.execPath, [scriptPath, ...scriptArgs], {
-        stdio: 'inherit',
-        cwd,
-        env: { ...process.env },
-    });
-    if (result.status !== 0) {
-        process.exit(result.status ?? 1);
-    }
-}
-function runWranglerDeploy(configPath, cwd) {
-    const result = spawnSync(process.execPath, [resolveWranglerBin(), 'deploy', '--config', configPath], {
-        stdio: 'inherit',
-        cwd,
-        env: { ...process.env },
-    });
-    if (result.status !== 0) {
-        process.exit(result.status ?? 1);
-    }
-}
-const options = parseArgs(process.argv.slice(2));
-const tenantRoot = process.cwd();
-const result = createFeatureBranchFromStaging(tenantRoot, options.branchName);
-pushBranch(result.repoDir, options.branchName, { setUpstream: true });
-if (!options.preview) {
-    console.log(`Created feature branch ${options.branchName} from staging.`);
-    console.log('Preview mode is disabled. Use local development for this branch.');
-    process.exit(0);
-}
-applyTreeseedEnvironmentToProcess({ tenantRoot, scope: 'staging' });
-assertTreeseedCommandEnvironment({ tenantRoot, scope: 'staging', purpose: 'deploy' });
-validateDeployPrerequisites(tenantRoot, { requireRemote: true });
-const target = createBranchPreviewDeployTarget(options.branchName);
-const summary = provisionCloudflareResources(tenantRoot, { target });
-printDeploySummary(summary);
-const { wranglerPath } = ensureGeneratedWranglerConfig(tenantRoot, { target });
-syncCloudflareSecrets(tenantRoot, { target });
-runRemoteD1Migrations(tenantRoot, { target });
-runNodeScript(packageScriptPath('tenant-build'), [], tenantRoot);
-runWranglerDeploy(wranglerPath, tenantRoot);
-const state = finalizeDeploymentState(tenantRoot, { target });
-console.log(`Treeseed start preview completed for ${options.branchName}.`);
-console.log(`Target: ${deployTargetLabel(target)}`);
-console.log(`Preview URL: ${state.lastDeployedUrl}`);

package/dist/scripts/workspace-test-unit.d.ts

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

package/dist/scripts/workspace-test-unit.js

@@ -1,4 +0,0 @@
-import { packagesWithScript, run } from './workspace-tools.js';
-for (const pkg of packagesWithScript('test:unit')) {
-    run('npm', ['run', 'test:unit'], { cwd: pkg.dir });
-}

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

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

package/dist/scripts/workspace-test.js

@@ -1,11 +0,0 @@
-import { sortWorkspacePackages, workspacePackages, run } from './workspace-tools.js';
-const packages = sortWorkspacePackages(workspacePackages());
-for (const pkg of packages) {
-    if (typeof pkg.packageJson.scripts?.['test:unit'] === 'string') {
-        run('npm', ['run', 'test:unit'], { cwd: pkg.dir });
-        continue;
-    }
-    if (typeof pkg.packageJson.scripts?.test === 'string') {
-        run('npm', ['run', 'test'], { cwd: pkg.dir });
-    }
-}

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

@@ -1,13 +0,0 @@
-export declare function workspaceRoot(): string;
-export declare function readJson(filePath: any): any;
-export declare function workspacePackageJson(root?: string): any;
-export declare function workspacePatterns(root?: string): any;
-export declare function isWorkspaceRoot(root?: string): boolean;
-export declare function workspacePackages(root?: string): any[];
-export declare function sortWorkspacePackages(packages: any): any[];
-export declare function packagesWithScript(scriptName: any, root?: string): any[];
-export declare function run(command: any, args: any, options?: {}): string;
-export declare function changedWorkspacePackages(options?: {}): any[];
-export declare function publishableWorkspacePackages(root?: string): any[];
-export declare function createTempDir(prefix: any): string;
-export declare function cleanupDir(dirPath: any): void;

package/dist/scripts/workspace-tools.js

@@ -1,226 +0,0 @@
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync } from 'node:fs';
-import { spawnSync } from 'node:child_process';
-import { join, relative, resolve } from 'node:path';
-function escapeRegex(source) {
-    return source.replace(/[|\\{}()[\]^$+?.]/g, '\\$&');
-}
-function segmentPatternToRegex(pattern) {
-    return new RegExp(`^${escapeRegex(pattern).replaceAll('*', '.*')}$`);
-}
-function expandWorkspacePattern(root, pattern) {
-    const segments = pattern.split(/[\\/]+/).filter(Boolean);
-    const results = [];
-    function visit(baseDir, index) {
-        if (index >= segments.length) {
-            results.push(baseDir);
-            return;
-        }
-        const segment = segments[index];
-        if (!segment.includes('*')) {
-            const nextDir = resolve(baseDir, segment);
-            if (existsSync(nextDir)) {
-                visit(nextDir, index + 1);
-            }
-            return;
-        }
-        if (!existsSync(baseDir)) {
-            return;
-        }
-        const matcher = segmentPatternToRegex(segment);
-        for (const entry of readdirSync(baseDir, { withFileTypes: true })) {
-            if (!entry.isDirectory() || !matcher.test(entry.name)) {
-                continue;
-            }
-            visit(resolve(baseDir, entry.name), index + 1);
-        }
-    }
-    visit(root, 0);
-    return results;
-}
-export function workspaceRoot() {
-    return process.cwd();
-}
-export function readJson(filePath) {
-    return JSON.parse(readFileSync(filePath, 'utf8'));
-}
-export function workspacePackageJson(root = workspaceRoot()) {
-    return readJson(resolve(root, 'package.json'));
-}
-export function workspacePatterns(root = workspaceRoot()) {
-    const packageJson = workspacePackageJson(root);
-    const workspaces = Array.isArray(packageJson.workspaces)
-        ? packageJson.workspaces
-        : Array.isArray(packageJson.workspaces?.packages)
-            ? packageJson.workspaces.packages
-            : [];
-    return workspaces.filter((value) => typeof value === 'string' && value.trim().length > 0);
-}
-export function isWorkspaceRoot(root = workspaceRoot()) {
-    return workspacePatterns(root).length > 0;
-}
-export function workspacePackages(root = workspaceRoot()) {
-    const discovered = new Map();
-    for (const pattern of workspacePatterns(root)) {
-        for (const dir of expandWorkspacePattern(root, pattern)) {
-            const packageJsonPath = resolve(dir, 'package.json');
-            if (!existsSync(packageJsonPath)) {
-                continue;
-            }
-            const packageJson = readJson(packageJsonPath);
-            discovered.set(dir, {
-                dir,
-                name: packageJson.name,
-                packageJson,
-                relativeDir: relative(root, dir).replaceAll('\\', '/'),
-            });
-        }
-    }
-    return [...discovered.values()].sort((left, right) => left.name.localeCompare(right.name));
-}
-function internalDependenciesFor(pkg, packageNames) {
-    const internalDeps = new Set();
-    for (const field of ['dependencies', 'optionalDependencies', 'peerDependencies', 'devDependencies']) {
-        for (const name of Object.keys(pkg.packageJson[field] ?? {})) {
-            if (packageNames.has(name)) {
-                internalDeps.add(name);
-            }
-        }
-    }
-    return internalDeps;
-}
-export function sortWorkspacePackages(packages) {
-    const packageMap = new Map(packages.map((pkg) => [pkg.name, pkg]));
-    const packageNames = new Set(packageMap.keys());
-    const dependents = new Map(packages.map((pkg) => [pkg.name, new Set()]));
-    const indegree = new Map(packages.map((pkg) => [pkg.name, 0]));
-    for (const pkg of packages) {
-        for (const dep of internalDependenciesFor(pkg, packageNames)) {
-            dependents.get(dep)?.add(pkg.name);
-            indegree.set(pkg.name, (indegree.get(pkg.name) ?? 0) + 1);
-        }
-    }
-    const ready = [...packages]
-        .filter((pkg) => (indegree.get(pkg.name) ?? 0) === 0)
-        .sort((left, right) => left.name.localeCompare(right.name));
-    const ordered = [];
-    while (ready.length > 0) {
-        const next = ready.shift();
-        if (!next) {
-            break;
-        }
-        ordered.push(next);
-        for (const dependentName of [...(dependents.get(next.name) ?? [])].sort()) {
-            const nextDegree = (indegree.get(dependentName) ?? 0) - 1;
-            indegree.set(dependentName, nextDegree);
-            if (nextDegree === 0) {
-                const dependent = packageMap.get(dependentName);
-                if (dependent) {
-                    ready.push(dependent);
-                    ready.sort((left, right) => left.name.localeCompare(right.name));
-                }
-            }
-        }
-    }
-    if (ordered.length !== packages.length) {
-        return [...packages].sort((left, right) => left.name.localeCompare(right.name));
-    }
-    return ordered;
-}
-export function packagesWithScript(scriptName, root = workspaceRoot()) {
-    return sortWorkspacePackages(workspacePackages(root).filter((pkg) => typeof pkg.packageJson.scripts?.[scriptName] === 'string'));
-}
-export function run(command, args, options = {}) {
-    const result = spawnSync(command, args, {
-        cwd: options.cwd ?? workspaceRoot(),
-        env: { ...process.env, ...(options.env ?? {}) },
-        stdio: options.capture ? 'pipe' : 'inherit',
-        encoding: 'utf8',
-        timeout: options.timeoutMs,
-    });
-    if (result.status !== 0) {
-        const message = (result.error?.message ? `${result.error.message}\n` : '')
-            + (result.stderr?.trim()
-                || result.stdout?.trim()
-                || `${command} ${args.join(' ')} failed`);
-        throw new Error(message);
-    }
-    return (result.stdout ?? '').trim();
-}
-function canResolveGitRef(baseRef, cwd = workspaceRoot()) {
-    const result = spawnSync('git', ['rev-parse', '--verify', baseRef], {
-        cwd,
-        stdio: 'pipe',
-        encoding: 'utf8',
-    });
-    return result.status === 0;
-}
-function resolveChangedFilesBaseRef(baseRef, cwd = workspaceRoot()) {
-    if (canResolveGitRef(baseRef, cwd)) {
-        return baseRef;
-    }
-    return null;
-}
-function changedWorkspaceFiles(baseRef, cwd = workspaceRoot()) {
-    const changedFiles = new Set();
-    const resolvedBaseRef = resolveChangedFilesBaseRef(baseRef, cwd);
-    const diffCommands = [
-        ['diff', '--name-only'],
-        ['diff', '--name-only', '--cached'],
-        ['ls-files', '--others', '--exclude-standard'],
-    ];
-    if (resolvedBaseRef) {
-        diffCommands.unshift(['diff', '--name-only', resolvedBaseRef, 'HEAD']);
-    }
-    for (const args of diffCommands) {
-        const output = run('git', args, { cwd, capture: true });
-        for (const line of output.split('\n').map((entry) => entry.trim()).filter(Boolean)) {
-            changedFiles.add(line);
-        }
-    }
-    return changedFiles;
-}
-export function changedWorkspacePackages(options = {}) {
-    const root = options.root ?? workspaceRoot();
-    const baseRef = options.baseRef ?? process.env.TREESEED_RELEASE_BASE_REF ?? 'HEAD^';
-    const includeDependents = options.includeDependents ?? false;
-    const packages = options.packages ?? workspacePackages(root);
-    const changedFiles = changedWorkspaceFiles(baseRef, root);
-    const changed = new Set(packages
-        .filter((pkg) => [...changedFiles].some((file) => file === pkg.relativeDir || file.startsWith(`${pkg.relativeDir}/`)))
-        .map((pkg) => pkg.name));
-    if (includeDependents && changed.size > 0) {
-        const packageMap = new Map(packages.map((pkg) => [pkg.name, pkg]));
-        const packageNames = new Set(packageMap.keys());
-        const reverseDeps = new Map(packages.map((pkg) => [pkg.name, new Set()]));
-        for (const pkg of packages) {
-            for (const dep of internalDependenciesFor(pkg, packageNames)) {
-                reverseDeps.get(dep)?.add(pkg.name);
-            }
-        }
-        const queue = [...changed];
-        while (queue.length > 0) {
-            const next = queue.shift();
-            for (const dependent of reverseDeps.get(next) ?? []) {
-                if (changed.has(dependent)) {
-                    continue;
-                }
-                changed.add(dependent);
-                queue.push(dependent);
-            }
-        }
-    }
-    return sortWorkspacePackages(packages.filter((pkg) => changed.has(pkg.name)));
-}
-export function publishableWorkspacePackages(root = workspaceRoot()) {
-    return packagesWithScript('release:publish', root);
-}
-export function createTempDir(prefix) {
-    const baseRoot = resolve(process.env.TREESEED_TEMP_ROOT ?? resolve(workspaceRoot(), '.local', 'tmp'));
-    mkdirSync(baseRoot, { recursive: true });
-    return mkdtempSync(join(baseRoot, prefix));
-}
-export function cleanupDir(dirPath) {
-    if (dirPath && existsSync(dirPath)) {
-        rmSync(dirPath, { recursive: true, force: true });
-    }
-}

package/dist/src/cli/handlers/continue.d.ts

@@ -1,2 +0,0 @@
-import type { TreeseedCommandHandler } from '../types.js';
-export declare const handleContinue: TreeseedCommandHandler;

package/dist/src/cli/handlers/prepare.d.ts

@@ -1,2 +0,0 @@
-import type { TreeseedCommandHandler } from '../types.js';
-export declare const handlePrepare: TreeseedCommandHandler;

package/dist/src/cli/handlers/promote.d.ts

@@ -1,2 +0,0 @@
-import type { TreeseedCommandHandler } from '../types.js';
-export declare const handlePromote: TreeseedCommandHandler;

package/dist/src/cli/handlers/publish.d.ts

@@ -1,2 +0,0 @@
-import type { TreeseedCommandHandler } from '../types.js';
-export declare const handlePublish: TreeseedCommandHandler;

package/dist/src/cli/handlers/setup.d.ts

@@ -1,2 +0,0 @@
-import type { TreeseedCommandHandler } from '../types.js';
-export declare const handleSetup: TreeseedCommandHandler;

package/dist/src/cli/handlers/start.d.ts

@@ -1,3 +0,0 @@
-import type { TreeseedCommandHandler } from '../types.js';
-export declare function provisionBranchPreview(branchName: string, context: Parameters<TreeseedCommandHandler>[1], commandName?: string): import("../types.js").TreeseedCommandResult;
-export declare const handleStart: TreeseedCommandHandler;

package/dist/src/cli/handlers/teardown.d.ts

@@ -1,2 +0,0 @@
-import type { TreeseedCommandHandler } from '../types.js';
-export declare const handleTeardown: TreeseedCommandHandler;

package/dist/src/cli/handlers/work.d.ts

@@ -1,2 +0,0 @@
-import type { TreeseedCommandHandler } from '../types.js';
-export declare const handleWork: TreeseedCommandHandler;

package/dist/src/cli/main.d.ts

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-export { runTreeseedCli, executeTreeseedCommand, createTreeseedCommandContext } from './runtime.js';
-export { renderTreeseedHelp, renderUsage, suggestTreeseedCommands } from './help.js';
-export { findCommandSpec, listCommandNames, TRESEED_COMMAND_SPECS } from './registry.js';
-export { parseTreeseedInvocation, validateTreeseedInvocation } from './parser.js';
-export type { TreeseedCommandContext, TreeseedCommandResult, TreeseedCommandSpec, TreeseedParsedInvocation, } from './types.js';

package/dist/src/cli/parser.d.ts

@@ -1,3 +0,0 @@
-import type { TreeseedCommandSpec, TreeseedParsedInvocation } from './types.js';
-export declare function parseTreeseedInvocation(command: TreeseedCommandSpec, argv: string[]): TreeseedParsedInvocation;
-export declare function validateTreeseedInvocation(command: TreeseedCommandSpec, invocation: TreeseedParsedInvocation): string[];

package/dist/src/cli/registry.d.ts

@@ -1,27 +0,0 @@
-import type { TreeseedCommandSpec } from './types.js';
-export declare const COMMAND_HANDLERS: {
-    readonly init: import("./types.js").TreeseedCommandHandler;
-    readonly config: import("./types.js").TreeseedCommandHandler;
-    readonly start: import("./types.js").TreeseedCommandHandler;
-    readonly close: import("./types.js").TreeseedCommandHandler;
-    readonly deploy: import("./types.js").TreeseedCommandHandler;
-    readonly save: import("./types.js").TreeseedCommandHandler;
-    readonly release: import("./types.js").TreeseedCommandHandler;
-    readonly destroy: import("./types.js").TreeseedCommandHandler;
-    readonly status: import("./types.js").TreeseedCommandHandler;
-    readonly next: import("./types.js").TreeseedCommandHandler;
-    readonly doctor: import("./types.js").TreeseedCommandHandler;
-    readonly setup: import("./types.js").TreeseedCommandHandler;
-    readonly work: import("./types.js").TreeseedCommandHandler;
-    readonly ship: import("./types.js").TreeseedCommandHandler;
-    readonly prepare: import("./types.js").TreeseedCommandHandler;
-    readonly publish: import("./types.js").TreeseedCommandHandler;
-    readonly promote: import("./types.js").TreeseedCommandHandler;
-    readonly teardown: import("./types.js").TreeseedCommandHandler;
-    readonly continue: import("./types.js").TreeseedCommandHandler;
-    readonly rollback: import("./types.js").TreeseedCommandHandler;
-};
-export declare const TRESEED_COMMAND_SPECS: TreeseedCommandSpec[];
-export declare const TRESEED_COMMAND_INDEX: Map<string, TreeseedCommandSpec>;
-export declare function findCommandSpec(name: string | null | undefined): TreeseedCommandSpec | null;
-export declare function listCommandNames(): string[];

package/dist/src/cli/runtime.d.ts

@@ -1,4 +0,0 @@
-import type { TreeseedCommandContext } from './types.js';
-export declare function createTreeseedCommandContext(overrides?: Partial<TreeseedCommandContext>): TreeseedCommandContext;
-export declare function executeTreeseedCommand(commandName: string, argv: string[], context: TreeseedCommandContext): Promise<number>;
-export declare function runTreeseedCli(argv: string[], overrides?: Partial<TreeseedCommandContext>): Promise<number>;

package/dist/src/cli/types.d.ts

@@ -1,71 +0,0 @@
-export type TreeseedCommandGroup = 'Workflow' | 'Local Development' | 'Validation' | 'Release Utilities' | 'Utilities' | 'Passthrough';
-export type TreeseedExecutionMode = 'handler' | 'adapter';
-export type TreeseedArgumentKind = 'positional' | 'message_tail';
-export type TreeseedOptionKind = 'boolean' | 'string' | 'enum';
-export type TreeseedCommandArgumentSpec = {
-    name: string;
-    description: string;
-    required?: boolean;
-    kind?: TreeseedArgumentKind;
-};
-export type TreeseedCommandOptionSpec = {
-    name: string;
-    flags: string;
-    description: string;
-    kind: TreeseedOptionKind;
-    repeatable?: boolean;
-    values?: string[];
-};
-export type TreeseedCommandExample = string;
-export type TreeseedParsedInvocation = {
-    commandName: string;
-    args: Record<string, string | string[] | boolean | undefined>;
-    positionals: string[];
-    rawArgs: string[];
-};
-export type TreeseedCommandResult = {
-    exitCode?: number;
-    stdout?: string[];
-    stderr?: string[];
-    report?: Record<string, unknown> | null;
-};
-export type TreeseedWriter = (output: string, stream?: 'stdout' | 'stderr') => void;
-export type TreeseedSpawner = (command: string, args: string[], options: {
-    cwd: string;
-    env: NodeJS.ProcessEnv;
-    stdio?: 'inherit';
-}) => {
-    status?: number | null;
-};
-export type TreeseedCommandContext = {
-    cwd: string;
-    env: NodeJS.ProcessEnv;
-    write: TreeseedWriter;
-    spawn: TreeseedSpawner;
-    outputFormat?: 'human' | 'json';
-};
-export type TreeseedCommandHandler = (invocation: TreeseedParsedInvocation, context: TreeseedCommandContext) => Promise<TreeseedCommandResult> | TreeseedCommandResult;
-export type TreeseedCommandSpec = {
-    name: string;
-    aliases: string[];
-    group: TreeseedCommandGroup;
-    summary: string;
-    description: string;
-    usage?: string;
-    arguments?: TreeseedCommandArgumentSpec[];
-    options?: TreeseedCommandOptionSpec[];
-    examples?: TreeseedCommandExample[];
-    notes?: string[];
-    related?: string[];
-    executionMode: TreeseedExecutionMode;
-    handlerName?: string;
-    adapter?: {
-        script: string;
-        workspaceScript?: string;
-        directScript?: string;
-        extraArgs?: string[];
-        rewriteArgs?: (args: string[]) => string[];
-        passthroughArgs?: boolean;
-        requireWorkspaceRoot?: boolean;
-    };
-};