@caryhu/codemine-forge 0.0.1-alpha.0

package/dist/package-resolution/resolver.d.ts

@@ -0,0 +1,17 @@
+import type { ForgePackageResolutionResult, ForgePackageResolver, ForgePackageResolverOptions, ForgeResolvePackagesOptions } from "./types";
+export declare class DefaultPackageResolver implements ForgePackageResolver {
+    private readonly options;
+    readonly capability: "package-resolution";
+    private readonly sources;
+    private readonly resolutionMode;
+    private readonly manifestPath;
+    private readonly now;
+    constructor(options: ForgePackageResolverOptions);
+    readManifest(manifestPath?: string): Promise<import("./types").ForgePackageManifest>;
+    resolve(options?: ForgeResolvePackagesOptions): Promise<ForgePackageResolutionResult>;
+    private resolveRequest;
+    private readCachedPackage;
+    private writeCachedPackage;
+}
+export declare function createPackageResolver(options: ForgePackageResolverOptions): ForgePackageResolver;
+export declare function createPackageCacheKey(packageName: string, versionOrRange: string): string;

package/dist/package-resolution/resolver.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPackageCacheKey = exports.createPackageResolver = exports.DefaultPackageResolver = void 0;
+const manifest_1 = require("./manifest");
+const diagnostics_1 = require("./diagnostics");
+const errors_1 = require("./errors");
+const types_1 = require("./types");
+const DEFAULT_RESOLUTION_MODE = "bundle-alias";
+class DefaultPackageResolver {
+    constructor(options) {
+        this.options = options;
+        this.capability = types_1.PACKAGE_RESOLUTION_CAPABILITY;
+        this.sources = options.sources ?? [];
+        this.resolutionMode = options.resolutionMode ?? DEFAULT_RESOLUTION_MODE;
+        this.manifestPath = options.manifestPath ?? manifest_1.DEFAULT_FORGE_MANIFEST_PATH;
+        this.now = options.now ?? (() => new Date().toISOString());
+    }
+    readManifest(manifestPath = this.manifestPath) {
+        return (0, manifest_1.readPackageManifest)(this.options.fileSystem, manifestPath);
+    }
+    async resolve(options = {}) {
+        const manifest = await this.readManifest(options.manifestPath ?? this.manifestPath);
+        const requests = (0, manifest_1.collectDependencyRequests)(manifest);
+        const sources = options.sources ?? this.sources;
+        const resolutionMode = options.resolutionMode ?? this.resolutionMode;
+        const packages = [];
+        for (const request of requests) {
+            packages.push(await this.resolveRequest(request, sources));
+        }
+        packages.sort((left, right) => left.name.localeCompare(right.name));
+        const lock = createLockMetadata(packages, resolutionMode);
+        const resultBase = {
+            manifest,
+            requests,
+            packages,
+            lock,
+            warnings: [],
+        };
+        if (resolutionMode === "import-map") {
+            return {
+                ...resultBase,
+                importMap: createImportMap(packages),
+            };
+        }
+        return {
+            ...resultBase,
+            aliases: createBundleAliases(packages),
+        };
+    }
+    async resolveRequest(request, sources) {
+        const cachedPackage = await this.readCachedPackage(request);
+        if (cachedPackage !== undefined) {
+            return cachedPackage;
+        }
+        for (const source of sources) {
+            const packageRecord = await source.resolvePackage(request);
+            if (packageRecord === undefined) {
+                continue;
+            }
+            const normalizedRecord = normalizePackageRecord(request, source.id, packageRecord);
+            await this.writeCachedPackage(request, normalizedRecord);
+            return normalizedRecord;
+        }
+        throw new errors_1.ForgePackageResolutionError((0, diagnostics_1.createUnresolvedPackageDiagnostic)(request.name, request.requestedRange));
+    }
+    async readCachedPackage(request) {
+        if (this.options.storage === undefined) {
+            return undefined;
+        }
+        const cacheRecord = await this.options.storage.getPackageCacheRecord(createPackageCacheKey(request.name, request.requestedRange));
+        if (cacheRecord === undefined || !isForgePackageRecord(cacheRecord.value)) {
+            return undefined;
+        }
+        return {
+            ...cacheRecord.value,
+            requestedRange: request.requestedRange,
+        };
+    }
+    async writeCachedPackage(request, packageRecord) {
+        if (this.options.storage === undefined) {
+            return;
+        }
+        const records = [
+            createCacheRecord(createPackageCacheKey(request.name, request.requestedRange), packageRecord, this.now()),
+        ];
+        if (request.requestedRange !== packageRecord.version) {
+            records.push(createCacheRecord(createPackageCacheKey(request.name, packageRecord.version), packageRecord, this.now()));
+        }
+        for (const record of records) {
+            await this.options.storage.putPackageCacheRecord(record);
+        }
+    }
+}
+exports.DefaultPackageResolver = DefaultPackageResolver;
+function createPackageResolver(options) {
+    return new DefaultPackageResolver(options);
+}
+exports.createPackageResolver = createPackageResolver;
+function createPackageCacheKey(packageName, versionOrRange) {
+    return `package:${encodeURIComponent(packageName)}@${encodeURIComponent(versionOrRange)}`;
+}
+exports.createPackageCacheKey = createPackageCacheKey;
+function normalizePackageRecord(request, sourceId, packageRecord) {
+    return {
+        ...packageRecord,
+        name: request.name,
+        requestedRange: request.requestedRange,
+        sourceId: packageRecord.sourceId || sourceId,
+        entry: normalizeEntryPath(packageRecord.entry),
+        dependencies: { ...packageRecord.dependencies },
+        files: { ...packageRecord.files },
+    };
+}
+function createLockMetadata(packages, resolutionMode) {
+    return {
+        lockfileVersion: 1,
+        resolutionMode,
+        packages: packages.map((packageRecord) => ({
+            name: packageRecord.name,
+            requestedRange: packageRecord.requestedRange,
+            version: packageRecord.version,
+            sourceId: packageRecord.sourceId,
+            entry: packageRecord.entry,
+            entryUrl: packageRecord.entryUrl,
+            integrity: packageRecord.integrity,
+        })),
+    };
+}
+function createImportMap(packages) {
+    return {
+        imports: Object.fromEntries(packages.map((packageRecord) => [
+            packageRecord.name,
+            packageRecord.entryUrl ?? createVirtualPackagePath(packageRecord),
+        ])),
+    };
+}
+function createBundleAliases(packages) {
+    return Object.fromEntries(packages.map((packageRecord) => [
+        packageRecord.name,
+        createVirtualPackagePath(packageRecord),
+    ]));
+}
+function createVirtualPackagePath(packageRecord) {
+    return `/.forge/packages/${packageRecord.name}@${packageRecord.version}${packageRecord.entry}`;
+}
+function normalizeEntryPath(entry) {
+    return entry.startsWith("/") ? entry : `/${entry}`;
+}
+function createCacheRecord(key, packageRecord, updatedAt) {
+    const encoded = new TextEncoder().encode(JSON.stringify(packageRecord));
+    return {
+        key,
+        value: packageRecord,
+        size: encoded.byteLength,
+        updatedAt,
+    };
+}
+function isForgePackageRecord(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const record = value;
+    return (typeof record.name === "string" &&
+        typeof record.version === "string" &&
+        typeof record.requestedRange === "string" &&
+        typeof record.sourceId === "string" &&
+        typeof record.entry === "string" &&
+        typeof record.dependencies === "object" &&
+        record.dependencies !== null &&
+        typeof record.files === "object" &&
+        record.files !== null);
+}

package/dist/package-resolution/types.d.ts

@@ -0,0 +1,98 @@
+import type { ForgeDiagnostic, ForgeVirtualFileSystemStorage } from "../virtual-file-system";
+import type { ForgeVirtualFileSystem } from "../virtual-file-system";
+export declare const PACKAGE_RESOLUTION_CAPABILITY: "package-resolution";
+export type ForgePackageResolutionMode = "import-map" | "bundle-alias";
+export type ForgePackageResolutionDiagnosticCode = "invalid_dependency" | "invalid_manifest" | "unresolved_package" | "unsupported_range";
+export interface ForgePackageResolutionDiagnostic {
+    readonly code: ForgePackageResolutionDiagnosticCode;
+    readonly severity: "error";
+    readonly message: string;
+    readonly path?: string;
+    readonly dependencyName?: string;
+    readonly requestedRange?: string;
+    readonly cause?: unknown;
+}
+export type ForgePackageDiagnostic = ForgeDiagnostic | ForgePackageResolutionDiagnostic;
+export interface ForgePackageManifest {
+    readonly name?: string;
+    readonly version?: string;
+    readonly type?: string;
+    readonly scripts: Record<string, string>;
+    readonly dependencies: Record<string, string>;
+    readonly devDependencies: Record<string, string>;
+    readonly imports: Record<string, unknown>;
+}
+export type ForgeDependencyKind = "dependency" | "devDependency";
+export interface ForgeDependencyRequest {
+    readonly name: string;
+    readonly requestedRange: string;
+    readonly kind: ForgeDependencyKind;
+}
+export interface ForgePackageFile {
+    readonly path: string;
+    readonly content?: string | Uint8Array;
+    readonly contentType?: string;
+    readonly size?: number;
+}
+export interface ForgePackageRecord {
+    readonly name: string;
+    readonly version: string;
+    readonly requestedRange: string;
+    readonly sourceId: string;
+    readonly entry: string;
+    readonly entryUrl?: string;
+    readonly browserEntry?: string;
+    readonly moduleEntry?: string;
+    readonly dependencies: Record<string, string>;
+    readonly files: Record<string, ForgePackageFile>;
+    readonly integrity?: string;
+}
+export interface ForgePackageLockPackage {
+    readonly name: string;
+    readonly requestedRange: string;
+    readonly version: string;
+    readonly sourceId: string;
+    readonly entry: string;
+    readonly entryUrl?: string;
+    readonly integrity?: string;
+}
+export interface ForgePackageLockMetadata {
+    readonly lockfileVersion: 1;
+    readonly resolutionMode: ForgePackageResolutionMode;
+    readonly packages: readonly ForgePackageLockPackage[];
+}
+export interface ForgeImportMap {
+    readonly imports: Record<string, string>;
+}
+export type ForgeBundleAliases = Record<string, string>;
+export interface ForgePackageSource {
+    readonly id: string;
+    resolvePackage(request: ForgeDependencyRequest): Promise<ForgePackageRecord | undefined>;
+}
+export interface ForgePackageResolverOptions {
+    readonly fileSystem: ForgeVirtualFileSystem;
+    readonly storage?: ForgeVirtualFileSystemStorage;
+    readonly sources?: readonly ForgePackageSource[];
+    readonly resolutionMode?: ForgePackageResolutionMode;
+    readonly manifestPath?: string;
+    readonly now?: () => string;
+}
+export interface ForgeResolvePackagesOptions {
+    readonly sources?: readonly ForgePackageSource[];
+    readonly resolutionMode?: ForgePackageResolutionMode;
+    readonly manifestPath?: string;
+}
+export interface ForgePackageResolutionResult {
+    readonly manifest: ForgePackageManifest;
+    readonly requests: readonly ForgeDependencyRequest[];
+    readonly packages: readonly ForgePackageRecord[];
+    readonly lock: ForgePackageLockMetadata;
+    readonly importMap?: ForgeImportMap;
+    readonly aliases?: ForgeBundleAliases;
+    readonly warnings: readonly ForgePackageDiagnostic[];
+}
+export interface ForgePackageResolver {
+    readonly capability: typeof PACKAGE_RESOLUTION_CAPABILITY;
+    readManifest(manifestPath?: string): Promise<ForgePackageManifest>;
+    resolve(options?: ForgeResolvePackagesOptions): Promise<ForgePackageResolutionResult>;
+}

package/dist/package-resolution/types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PACKAGE_RESOLUTION_CAPABILITY = void 0;
+exports.PACKAGE_RESOLUTION_CAPABILITY = "package-resolution";

package/dist/terminal-commands/diagnostics.d.ts

@@ -0,0 +1,3 @@
+import type { ForgeTerminalDiagnostic } from "./types";
+export declare function createParseErrorDiagnostic(commandText: string, message: string): ForgeTerminalDiagnostic;
+export declare function createUnsupportedCommandDiagnostic(commandText: string): ForgeTerminalDiagnostic;

package/dist/terminal-commands/diagnostics.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUnsupportedCommandDiagnostic = exports.createParseErrorDiagnostic = void 0;
+function createParseErrorDiagnostic(commandText, message) {
+    return {
+        code: "parse_error",
+        severity: "error",
+        message,
+        commandText,
+    };
+}
+exports.createParseErrorDiagnostic = createParseErrorDiagnostic;
+function createUnsupportedCommandDiagnostic(commandText) {
+    return {
+        code: "unsupported_command",
+        severity: "error",
+        message: "Command is not supported by Forge.",
+        commandText,
+    };
+}
+exports.createUnsupportedCommandDiagnostic = createUnsupportedCommandDiagnostic;

package/dist/terminal-commands/index.d.ts

@@ -0,0 +1,7 @@
+export { createParseErrorDiagnostic, createUnsupportedCommandDiagnostic, } from "./diagnostics";
+export { createNpmRunBuildCommandHandler, NpmRunBuildCommandHandler, } from "./npm-build";
+export { createNpmInstallCommandHandler, NpmInstallCommandHandler, } from "./npm-install";
+export { createNpmRunDevCommandHandler, NpmRunDevCommandHandler, } from "./npm-dev";
+export { parseForgeCommandText } from "./parser";
+export { createForgeTerminal, DefaultForgeTerminal } from "./terminal";
+export { TERMINAL_COMMANDS_CAPABILITY, type ForgeCommand, type ForgeCommandContext, type ForgeCommandDiagnostic, type ForgeCommandHandler, type ForgeCommandParseResult, type ForgeCommandResult, type ForgeTerminal, type ForgeTerminalDiagnostic, type ForgeTerminalDiagnosticCode, type ForgeTerminalExecuteOptions, type ForgeTerminalOptions, type ForgeTerminalOutputKind, type ForgeTerminalOutputLine, } from "./types";

package/dist/terminal-commands/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TERMINAL_COMMANDS_CAPABILITY = exports.DefaultForgeTerminal = exports.createForgeTerminal = exports.parseForgeCommandText = exports.NpmRunDevCommandHandler = exports.createNpmRunDevCommandHandler = exports.NpmInstallCommandHandler = exports.createNpmInstallCommandHandler = exports.NpmRunBuildCommandHandler = exports.createNpmRunBuildCommandHandler = exports.createUnsupportedCommandDiagnostic = exports.createParseErrorDiagnostic = void 0;
+var diagnostics_1 = require("./diagnostics");
+Object.defineProperty(exports, "createParseErrorDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createParseErrorDiagnostic; } });
+Object.defineProperty(exports, "createUnsupportedCommandDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createUnsupportedCommandDiagnostic; } });
+var npm_build_1 = require("./npm-build");
+Object.defineProperty(exports, "createNpmRunBuildCommandHandler", { enumerable: true, get: function () { return npm_build_1.createNpmRunBuildCommandHandler; } });
+Object.defineProperty(exports, "NpmRunBuildCommandHandler", { enumerable: true, get: function () { return npm_build_1.NpmRunBuildCommandHandler; } });
+var npm_install_1 = require("./npm-install");
+Object.defineProperty(exports, "createNpmInstallCommandHandler", { enumerable: true, get: function () { return npm_install_1.createNpmInstallCommandHandler; } });
+Object.defineProperty(exports, "NpmInstallCommandHandler", { enumerable: true, get: function () { return npm_install_1.NpmInstallCommandHandler; } });
+var npm_dev_1 = require("./npm-dev");
+Object.defineProperty(exports, "createNpmRunDevCommandHandler", { enumerable: true, get: function () { return npm_dev_1.createNpmRunDevCommandHandler; } });
+Object.defineProperty(exports, "NpmRunDevCommandHandler", { enumerable: true, get: function () { return npm_dev_1.NpmRunDevCommandHandler; } });
+var parser_1 = require("./parser");
+Object.defineProperty(exports, "parseForgeCommandText", { enumerable: true, get: function () { return parser_1.parseForgeCommandText; } });
+var terminal_1 = require("./terminal");
+Object.defineProperty(exports, "createForgeTerminal", { enumerable: true, get: function () { return terminal_1.createForgeTerminal; } });
+Object.defineProperty(exports, "DefaultForgeTerminal", { enumerable: true, get: function () { return terminal_1.DefaultForgeTerminal; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "TERMINAL_COMMANDS_CAPABILITY", { enumerable: true, get: function () { return types_1.TERMINAL_COMMANDS_CAPABILITY; } });

package/dist/terminal-commands/npm-build.d.ts

@@ -0,0 +1,7 @@
+import type { ForgeCommand, ForgeCommandContext, ForgeCommandHandler, ForgeCommandResult } from "./types";
+export declare class NpmRunBuildCommandHandler implements ForgeCommandHandler {
+    readonly name = "npm run build";
+    canRun(command: ForgeCommand): boolean;
+    run(context: ForgeCommandContext): Promise<ForgeCommandResult>;
+}
+export declare function createNpmRunBuildCommandHandler(): ForgeCommandHandler;

package/dist/terminal-commands/npm-build.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNpmRunBuildCommandHandler = exports.NpmRunBuildCommandHandler = void 0;
+class NpmRunBuildCommandHandler {
+    constructor() {
+        this.name = "npm run build";
+    }
+    canRun(command) {
+        return (command.argv.length === 3 &&
+            command.argv[0] === "npm" &&
+            command.argv[1] === "run" &&
+            command.argv[2] === "build");
+    }
+    async run(context) {
+        if (context.buildPipeline === undefined) {
+            return {
+                command: context.command,
+                exitCode: 127,
+                output: [stderr("Forge build pipeline is not configured.")],
+                diagnostics: [],
+            };
+        }
+        const buildResult = await context.buildPipeline.build();
+        if (!buildResult.success) {
+            const firstDiagnostic = buildResult.diagnostics[0];
+            return {
+                command: context.command,
+                exitCode: 1,
+                output: [stderr(firstDiagnostic?.message ?? "Forge build failed.")],
+                diagnostics: buildResult.diagnostics,
+                buildResult,
+            };
+        }
+        return {
+            command: context.command,
+            exitCode: 0,
+            output: [
+                stdout(`Forge emitted browser bundle for ${buildResult.entry}.`),
+                stdout("Forge wrote build manifest at /.forge/build/build-manifest.json."),
+                stdout(`Bundle entry: ${buildResult.browserBundle?.entryOutputPath ?? "unavailable"}.`),
+                ...warningOutput(buildResult.diagnostics),
+            ],
+            diagnostics: buildResult.diagnostics,
+            buildResult,
+        };
+    }
+}
+exports.NpmRunBuildCommandHandler = NpmRunBuildCommandHandler;
+function createNpmRunBuildCommandHandler() {
+    return new NpmRunBuildCommandHandler();
+}
+exports.createNpmRunBuildCommandHandler = createNpmRunBuildCommandHandler;
+function stdout(text) {
+    return { kind: "stdout", text };
+}
+function stderr(text) {
+    return { kind: "stderr", text };
+}
+function warningOutput(diagnostics) {
+    return diagnostics
+        .filter((diagnostic) => diagnostic.severity === "warning")
+        .map((diagnostic) => stderr(`Forge warning: ${diagnostic.message}`));
+}

package/dist/terminal-commands/npm-dev.d.ts

@@ -0,0 +1,7 @@
+import type { ForgeCommand, ForgeCommandContext, ForgeCommandHandler, ForgeCommandResult } from "./types";
+export declare class NpmRunDevCommandHandler implements ForgeCommandHandler {
+    readonly name = "npm run dev";
+    canRun(command: ForgeCommand): boolean;
+    run(context: ForgeCommandContext): Promise<ForgeCommandResult>;
+}
+export declare function createNpmRunDevCommandHandler(): ForgeCommandHandler;

package/dist/terminal-commands/npm-dev.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNpmRunDevCommandHandler = exports.NpmRunDevCommandHandler = void 0;
+class NpmRunDevCommandHandler {
+    constructor() {
+        this.name = "npm run dev";
+    }
+    canRun(command) {
+        return (command.argv.length === 3 &&
+            command.argv[0] === "npm" &&
+            command.argv[1] === "run" &&
+            command.argv[2] === "dev");
+    }
+    async run(context) {
+        if (context.devServerPreview === undefined) {
+            return {
+                command: context.command,
+                exitCode: 127,
+                output: [stderr("Forge dev server preview is not configured.")],
+                diagnostics: [],
+            };
+        }
+        const startResult = await context.devServerPreview.start();
+        if (!startResult.success) {
+            const firstDiagnostic = startResult.diagnostics[0];
+            return {
+                command: context.command,
+                exitCode: 1,
+                output: [
+                    stderr(firstDiagnostic?.message ?? "Forge dev session failed to start."),
+                ],
+                diagnostics: startResult.diagnostics,
+                buildResult: startResult.buildResult,
+                devSession: startResult.session,
+            };
+        }
+        return {
+            command: context.command,
+            exitCode: 0,
+            output: [
+                stdout(`Forge started browser preview session ${startResult.session.id}.`),
+                stdout(`Preview URL: ${startResult.session.previewUrl}`),
+                stdout(`Preview revision ${startResult.session.revision} is ready as iframe HTML.`),
+                stdout("No real Vite server or TCP port was opened."),
+                ...warningOutput(startResult.diagnostics),
+            ],
+            diagnostics: startResult.diagnostics,
+            buildResult: startResult.buildResult,
+            devSession: startResult.session,
+        };
+    }
+}
+exports.NpmRunDevCommandHandler = NpmRunDevCommandHandler;
+function createNpmRunDevCommandHandler() {
+    return new NpmRunDevCommandHandler();
+}
+exports.createNpmRunDevCommandHandler = createNpmRunDevCommandHandler;
+function stdout(text) {
+    return { kind: "stdout", text };
+}
+function stderr(text) {
+    return { kind: "stderr", text };
+}
+function warningOutput(diagnostics) {
+    return diagnostics
+        .filter((diagnostic) => diagnostic.severity === "warning")
+        .map((diagnostic) => stderr(`Forge warning: ${diagnostic.message}`));
+}

package/dist/terminal-commands/npm-install.d.ts

@@ -0,0 +1,8 @@
+import type { ForgeCommand, ForgeCommandContext, ForgeCommandHandler, ForgeCommandResult } from "./types";
+export declare class NpmInstallCommandHandler implements ForgeCommandHandler {
+    readonly name = "npm install";
+    readonly aliases: string[];
+    canRun(command: ForgeCommand): boolean;
+    run(context: ForgeCommandContext): Promise<ForgeCommandResult>;
+}
+export declare function createNpmInstallCommandHandler(): ForgeCommandHandler;

package/dist/terminal-commands/npm-install.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNpmInstallCommandHandler = exports.NpmInstallCommandHandler = void 0;
+const package_resolution_1 = require("../package-resolution");
+class NpmInstallCommandHandler {
+    constructor() {
+        this.name = "npm install";
+        this.aliases = ["npm i"];
+    }
+    canRun(command) {
+        return (command.argv.length === 2 &&
+            command.argv[0] === "npm" &&
+            (command.argv[1] === "install" || command.argv[1] === "i"));
+    }
+    async run(context) {
+        try {
+            const packageResolution = await context.packageResolver.resolve();
+            const packageCount = packageResolution.packages.length;
+            const mode = packageResolution.lock.resolutionMode;
+            const output = [
+                stdout(`Forge resolved ${packageCount} package${packageCount === 1 ? "" : "s"}.`),
+                stdout(`Forge prepared browser package metadata using ${mode} mode.`),
+                stdout("No real node_modules directory was created."),
+            ];
+            return {
+                command: context.command,
+                exitCode: 0,
+                output,
+                diagnostics: [],
+                packageResolution,
+            };
+        }
+        catch (error) {
+            if (error instanceof package_resolution_1.ForgePackageResolutionError) {
+                return {
+                    command: context.command,
+                    exitCode: 1,
+                    output: [stderr(error.diagnostic.message)],
+                    diagnostics: [error.diagnostic],
+                };
+            }
+            throw error;
+        }
+    }
+}
+exports.NpmInstallCommandHandler = NpmInstallCommandHandler;
+function createNpmInstallCommandHandler() {
+    return new NpmInstallCommandHandler();
+}
+exports.createNpmInstallCommandHandler = createNpmInstallCommandHandler;
+function stdout(text) {
+    return { kind: "stdout", text };
+}
+function stderr(text) {
+    return { kind: "stderr", text };
+}

package/dist/terminal-commands/parser.d.ts

@@ -0,0 +1,2 @@
+import type { ForgeCommandParseResult } from "./types";
+export declare function parseForgeCommandText(commandText: string): ForgeCommandParseResult;

package/dist/terminal-commands/parser.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseForgeCommandText = void 0;
+const diagnostics_1 = require("./diagnostics");
+function parseForgeCommandText(commandText) {
+    const argv = [];
+    let current = "";
+    let quote;
+    for (let index = 0; index < commandText.length; index += 1) {
+        const char = commandText[index];
+        if (quote !== undefined) {
+            if (char === quote) {
+                quote = undefined;
+                continue;
+            }
+            current += char;
+            continue;
+        }
+        if (char === "\"" || char === "'") {
+            quote = char;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            if (current.length > 0) {
+                argv.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (quote !== undefined) {
+        return {
+            ok: false,
+            diagnostic: (0, diagnostics_1.createParseErrorDiagnostic)(commandText, "Command contains an unterminated quoted argument."),
+        };
+    }
+    if (current.length > 0) {
+        argv.push(current);
+    }
+    if (argv.length === 0) {
+        return {
+            ok: false,
+            diagnostic: (0, diagnostics_1.createParseErrorDiagnostic)(commandText, "Command text is empty."),
+        };
+    }
+    return {
+        ok: true,
+        argv,
+    };
+}
+exports.parseForgeCommandText = parseForgeCommandText;

package/dist/terminal-commands/terminal.d.ts

@@ -0,0 +1,12 @@
+import { type ForgeCommandResult, type ForgeTerminal, type ForgeTerminalOptions } from "./types";
+export declare class DefaultForgeTerminal implements ForgeTerminal {
+    private readonly options;
+    readonly capability: "terminal-commands";
+    private readonly handlers;
+    private readonly cwd;
+    constructor(options: ForgeTerminalOptions);
+    execute(commandText: string, executeOptions?: {
+        readonly cwd?: string;
+    }): Promise<ForgeCommandResult>;
+}
+export declare function createForgeTerminal(options: ForgeTerminalOptions): ForgeTerminal;