@caryhu/codemine-forge 0.0.1-alpha.0

package/dist/terminal-commands/terminal.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createForgeTerminal = exports.DefaultForgeTerminal = void 0;
+const diagnostics_1 = require("./diagnostics");
+const npm_build_1 = require("./npm-build");
+const npm_dev_1 = require("./npm-dev");
+const npm_install_1 = require("./npm-install");
+const parser_1 = require("./parser");
+const types_1 = require("./types");
+class DefaultForgeTerminal {
+    constructor(options) {
+        this.options = options;
+        this.capability = types_1.TERMINAL_COMMANDS_CAPABILITY;
+        this.handlers = options.handlers ?? createDefaultHandlers(options);
+        this.cwd = options.cwd ?? "/";
+    }
+    async execute(commandText, executeOptions = {}) {
+        const parsed = (0, parser_1.parseForgeCommandText)(commandText);
+        const cwd = executeOptions.cwd ?? this.cwd;
+        if (!parsed.ok) {
+            const command = createCommand(commandText, [], cwd);
+            return {
+                command,
+                exitCode: 2,
+                output: [stderr(parsed.diagnostic.message)],
+                diagnostics: [parsed.diagnostic],
+            };
+        }
+        const command = createCommand(commandText, parsed.argv, cwd);
+        const handler = this.handlers.find((candidate) => candidate.canRun(command));
+        if (handler === undefined) {
+            const diagnostic = (0, diagnostics_1.createUnsupportedCommandDiagnostic)(commandText);
+            return {
+                command,
+                exitCode: 127,
+                output: [stderr(diagnostic.message)],
+                diagnostics: [diagnostic],
+            };
+        }
+        return handler.run({
+            command,
+            buildPipeline: this.options.buildPipeline,
+            devServerPreview: this.options.devServerPreview,
+            packageResolver: this.options.packageResolver,
+        });
+    }
+}
+exports.DefaultForgeTerminal = DefaultForgeTerminal;
+function createForgeTerminal(options) {
+    return new DefaultForgeTerminal(options);
+}
+exports.createForgeTerminal = createForgeTerminal;
+function createCommand(raw, argv, cwd) {
+    return {
+        raw,
+        name: argv[0] ?? "",
+        argv,
+        cwd,
+    };
+}
+function stderr(text) {
+    return { kind: "stderr", text };
+}
+function createDefaultHandlers(options) {
+    const handlers = [(0, npm_install_1.createNpmInstallCommandHandler)()];
+    if (options.buildPipeline !== undefined) {
+        handlers.push((0, npm_build_1.createNpmRunBuildCommandHandler)());
+    }
+    if (options.devServerPreview !== undefined) {
+        handlers.push((0, npm_dev_1.createNpmRunDevCommandHandler)());
+    }
+    return handlers;
+}

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

@@ -0,0 +1,65 @@
+import type { ForgeBuildPipeline, ForgeBuildResult } from "../build-pipeline";
+import type { ForgeDevServerPreview, ForgeDevSession, ForgeDevSessionDiagnostic } from "../dev-server-preview";
+import type { ForgePackageDiagnostic, ForgePackageResolutionResult, ForgePackageResolver } from "../package-resolution";
+export declare const TERMINAL_COMMANDS_CAPABILITY: "terminal-commands";
+export type ForgeTerminalDiagnosticCode = "parse_error" | "unsupported_command";
+export interface ForgeTerminalDiagnostic {
+    readonly code: ForgeTerminalDiagnosticCode;
+    readonly severity: "error";
+    readonly message: string;
+    readonly commandText?: string;
+}
+export type ForgeCommandDiagnostic = ForgeBuildResult["diagnostics"][number] | ForgeDevSessionDiagnostic | ForgeTerminalDiagnostic | ForgePackageDiagnostic;
+export interface ForgeCommand {
+    readonly raw: string;
+    readonly name: string;
+    readonly argv: readonly string[];
+    readonly cwd: string;
+}
+export type ForgeTerminalOutputKind = "stdout" | "stderr";
+export interface ForgeTerminalOutputLine {
+    readonly kind: ForgeTerminalOutputKind;
+    readonly text: string;
+}
+export interface ForgeCommandResult {
+    readonly command: ForgeCommand;
+    readonly exitCode: number;
+    readonly output: readonly ForgeTerminalOutputLine[];
+    readonly diagnostics: readonly ForgeCommandDiagnostic[];
+    readonly buildResult?: ForgeBuildResult;
+    readonly devSession?: ForgeDevSession;
+    readonly packageResolution?: ForgePackageResolutionResult;
+}
+export interface ForgeCommandContext {
+    readonly command: ForgeCommand;
+    readonly buildPipeline?: ForgeBuildPipeline;
+    readonly devServerPreview?: ForgeDevServerPreview;
+    readonly packageResolver: ForgePackageResolver;
+}
+export interface ForgeCommandHandler {
+    readonly name: string;
+    readonly aliases?: readonly string[];
+    canRun(command: ForgeCommand): boolean;
+    run(context: ForgeCommandContext): Promise<ForgeCommandResult>;
+}
+export interface ForgeTerminalExecuteOptions {
+    readonly cwd?: string;
+}
+export interface ForgeTerminalOptions {
+    readonly buildPipeline?: ForgeBuildPipeline;
+    readonly devServerPreview?: ForgeDevServerPreview;
+    readonly packageResolver: ForgePackageResolver;
+    readonly handlers?: readonly ForgeCommandHandler[];
+    readonly cwd?: string;
+}
+export interface ForgeTerminal {
+    readonly capability: typeof TERMINAL_COMMANDS_CAPABILITY;
+    execute(commandText: string, options?: ForgeTerminalExecuteOptions): Promise<ForgeCommandResult>;
+}
+export type ForgeCommandParseResult = {
+    readonly ok: true;
+    readonly argv: readonly string[];
+} | {
+    readonly ok: false;
+    readonly diagnostic: ForgeTerminalDiagnostic;
+};

package/dist/terminal-commands/types.js

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

package/dist/virtual-file-system/diagnostics.d.ts

@@ -0,0 +1,14 @@
+import type { ForgeDiagnostic, ForgeDiagnosticCode } from "./types";
+export interface ForgeDiagnosticInput {
+    readonly code: ForgeDiagnosticCode;
+    readonly message: string;
+    readonly path?: string;
+    readonly relatedPath?: string;
+    readonly cause?: unknown;
+}
+export declare function createForgeDiagnostic(input: ForgeDiagnosticInput): ForgeDiagnostic;
+export declare function createInvalidPathDiagnostic(path: string, message?: string): ForgeDiagnostic;
+export declare function createPathTraversalDiagnostic(path: string): ForgeDiagnostic;
+export declare function createNotFoundDiagnostic(path: string): ForgeDiagnostic;
+export declare function createMissingParentDiagnostic(path: string): ForgeDiagnostic;
+export declare function createNotImplementedDiagnostic(operation: string, path?: string, relatedPath?: string): ForgeDiagnostic;

package/dist/virtual-file-system/diagnostics.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNotImplementedDiagnostic = exports.createMissingParentDiagnostic = exports.createNotFoundDiagnostic = exports.createPathTraversalDiagnostic = exports.createInvalidPathDiagnostic = exports.createForgeDiagnostic = void 0;
+function createForgeDiagnostic(input) {
+    return {
+        code: input.code,
+        severity: "error",
+        message: input.message,
+        path: input.path,
+        relatedPath: input.relatedPath,
+        cause: input.cause,
+    };
+}
+exports.createForgeDiagnostic = createForgeDiagnostic;
+function createInvalidPathDiagnostic(path, message = "Path is invalid.") {
+    return createForgeDiagnostic({
+        code: "invalid_path",
+        message,
+        path,
+    });
+}
+exports.createInvalidPathDiagnostic = createInvalidPathDiagnostic;
+function createPathTraversalDiagnostic(path) {
+    return createForgeDiagnostic({
+        code: "path_traversal",
+        message: "Path traversal outside the workspace root is not allowed.",
+        path,
+    });
+}
+exports.createPathTraversalDiagnostic = createPathTraversalDiagnostic;
+function createNotFoundDiagnostic(path) {
+    return createForgeDiagnostic({
+        code: "not_found",
+        message: "Path does not exist in the workspace.",
+        path,
+    });
+}
+exports.createNotFoundDiagnostic = createNotFoundDiagnostic;
+function createMissingParentDiagnostic(path) {
+    return createForgeDiagnostic({
+        code: "missing_parent",
+        message: "Parent directory does not exist in the workspace.",
+        path,
+    });
+}
+exports.createMissingParentDiagnostic = createMissingParentDiagnostic;
+function createNotImplementedDiagnostic(operation, path, relatedPath) {
+    return createForgeDiagnostic({
+        code: "not_implemented",
+        message: `Virtual file system operation is not implemented: ${operation}.`,
+        path,
+        relatedPath,
+    });
+}
+exports.createNotImplementedDiagnostic = createNotImplementedDiagnostic;

package/dist/virtual-file-system/errors.d.ts

@@ -0,0 +1,5 @@
+import type { ForgeDiagnostic } from "./types";
+export declare class ForgeFileSystemError extends Error {
+    readonly diagnostic: ForgeDiagnostic;
+    constructor(diagnostic: ForgeDiagnostic);
+}

package/dist/virtual-file-system/errors.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForgeFileSystemError = void 0;
+class ForgeFileSystemError extends Error {
+    constructor(diagnostic) {
+        super(diagnostic.message);
+        this.diagnostic = diagnostic;
+        this.name = "ForgeFileSystemError";
+    }
+}
+exports.ForgeFileSystemError = ForgeFileSystemError;

package/dist/virtual-file-system/index.d.ts

@@ -0,0 +1,26 @@
+import type { ForgeDeleteOptions, ForgeDirEntry, ForgeFileStat, ForgeFileWatchListener, ForgeMkdirOptions, ForgeOpenVirtualFileSystemOptions, ForgeRestoreOptions, ForgeSnapshot, ForgeSnapshotOptions, ForgeUnsubscribe, ForgeVirtualFileSystemOptions, ForgeWriteFileOptions } from "./types";
+export { DEFAULT_FORGE_VFS_LIMITS, createLimitExceededDiagnostic, resolveForgeVirtualFileSystemLimits, } from "./limits";
+export { createForgeDiagnostic, createInvalidPathDiagnostic, createMissingParentDiagnostic, createNotFoundDiagnostic, createNotImplementedDiagnostic, createPathTraversalDiagnostic, type ForgeDiagnosticInput, } from "./diagnostics";
+export { normalizeForgePath, type ForgePathNormalizationResult, } from "./path";
+export { ForgeFileSystemError } from "./errors";
+export { InMemoryVirtualFileSystem } from "./memory";
+export { createIndexedDbForgeStorage, FORGE_INDEXED_DB_NAME, FORGE_INDEXED_DB_STORES, FORGE_INDEXED_DB_VERSION, IndexedDbForgeStorage, type IndexedDbForgeStorageOptions, } from "./storage";
+export type { ForgeBuildCacheRecord, ForgeDeleteOptions, ForgeDiagnostic, ForgeDiagnosticCode, ForgeDiagnosticSeverity, ForgeDirEntry, ForgeFileCreatedEvent, ForgeFileDeletedEvent, ForgeFileEvent, ForgeFileKind, ForgeFileRecord, ForgeFileRenamedEvent, ForgeFileSource, ForgeFileStat, ForgeFileUpdatedEvent, ForgeFileWatchListener, ForgeLimitDiagnostic, ForgeMkdirOptions, ForgeOpenVirtualFileSystemOptions, ForgePackageCacheRecord, ForgePersistedWorkspace, ForgeVirtualFileSystemLimits, ResolvedForgeVirtualFileSystemLimits, ForgeRestoreOptions, ForgeSnapshot, ForgeSnapshotOptions, ForgeUnsubscribe, ForgeVirtualFileSystemOptions, ForgeVirtualFileSystemStorage, ForgeWorkspace, ForgeWorkspaceMetadata, ForgeWriteFileOptions, } from "./types";
+export declare const VIRTUAL_FILE_SYSTEM_CAPABILITY: "virtual-file-system";
+export interface ForgeVirtualFileSystem {
+    readonly capability: typeof VIRTUAL_FILE_SYSTEM_CAPABILITY;
+    readFile(path: string): Promise<Uint8Array>;
+    readText(path: string): Promise<string>;
+    writeFile(path: string, content: Uint8Array | string, options?: ForgeWriteFileOptions): Promise<void>;
+    delete(path: string, options?: ForgeDeleteOptions): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    mkdir(path: string, options?: ForgeMkdirOptions): Promise<void>;
+    readdir(path: string): Promise<readonly ForgeDirEntry[]>;
+    stat(path: string): Promise<ForgeFileStat>;
+    exists(path: string): Promise<boolean>;
+    snapshot(options?: ForgeSnapshotOptions): Promise<ForgeSnapshot>;
+    restore(snapshot: ForgeSnapshot, options?: ForgeRestoreOptions): Promise<void>;
+    watch(listener: ForgeFileWatchListener): ForgeUnsubscribe;
+}
+export declare function createVirtualFileSystem(options?: ForgeVirtualFileSystemOptions): ForgeVirtualFileSystem;
+export declare function openVirtualFileSystem(options: ForgeOpenVirtualFileSystemOptions): Promise<ForgeVirtualFileSystem>;

package/dist/virtual-file-system/index.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openVirtualFileSystem = exports.createVirtualFileSystem = exports.VIRTUAL_FILE_SYSTEM_CAPABILITY = exports.IndexedDbForgeStorage = exports.FORGE_INDEXED_DB_VERSION = exports.FORGE_INDEXED_DB_STORES = exports.FORGE_INDEXED_DB_NAME = exports.createIndexedDbForgeStorage = exports.InMemoryVirtualFileSystem = exports.ForgeFileSystemError = exports.normalizeForgePath = exports.createPathTraversalDiagnostic = exports.createNotImplementedDiagnostic = exports.createNotFoundDiagnostic = exports.createMissingParentDiagnostic = exports.createInvalidPathDiagnostic = exports.createForgeDiagnostic = exports.resolveForgeVirtualFileSystemLimits = exports.createLimitExceededDiagnostic = exports.DEFAULT_FORGE_VFS_LIMITS = void 0;
+const memory_1 = require("./memory");
+const storage_1 = require("./storage");
+var limits_1 = require("./limits");
+Object.defineProperty(exports, "DEFAULT_FORGE_VFS_LIMITS", { enumerable: true, get: function () { return limits_1.DEFAULT_FORGE_VFS_LIMITS; } });
+Object.defineProperty(exports, "createLimitExceededDiagnostic", { enumerable: true, get: function () { return limits_1.createLimitExceededDiagnostic; } });
+Object.defineProperty(exports, "resolveForgeVirtualFileSystemLimits", { enumerable: true, get: function () { return limits_1.resolveForgeVirtualFileSystemLimits; } });
+var diagnostics_1 = require("./diagnostics");
+Object.defineProperty(exports, "createForgeDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createForgeDiagnostic; } });
+Object.defineProperty(exports, "createInvalidPathDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createInvalidPathDiagnostic; } });
+Object.defineProperty(exports, "createMissingParentDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createMissingParentDiagnostic; } });
+Object.defineProperty(exports, "createNotFoundDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createNotFoundDiagnostic; } });
+Object.defineProperty(exports, "createNotImplementedDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createNotImplementedDiagnostic; } });
+Object.defineProperty(exports, "createPathTraversalDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createPathTraversalDiagnostic; } });
+var path_1 = require("./path");
+Object.defineProperty(exports, "normalizeForgePath", { enumerable: true, get: function () { return path_1.normalizeForgePath; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "ForgeFileSystemError", { enumerable: true, get: function () { return errors_1.ForgeFileSystemError; } });
+var memory_2 = require("./memory");
+Object.defineProperty(exports, "InMemoryVirtualFileSystem", { enumerable: true, get: function () { return memory_2.InMemoryVirtualFileSystem; } });
+var storage_2 = require("./storage");
+Object.defineProperty(exports, "createIndexedDbForgeStorage", { enumerable: true, get: function () { return storage_2.createIndexedDbForgeStorage; } });
+Object.defineProperty(exports, "FORGE_INDEXED_DB_NAME", { enumerable: true, get: function () { return storage_2.FORGE_INDEXED_DB_NAME; } });
+Object.defineProperty(exports, "FORGE_INDEXED_DB_STORES", { enumerable: true, get: function () { return storage_2.FORGE_INDEXED_DB_STORES; } });
+Object.defineProperty(exports, "FORGE_INDEXED_DB_VERSION", { enumerable: true, get: function () { return storage_2.FORGE_INDEXED_DB_VERSION; } });
+Object.defineProperty(exports, "IndexedDbForgeStorage", { enumerable: true, get: function () { return storage_2.IndexedDbForgeStorage; } });
+exports.VIRTUAL_FILE_SYSTEM_CAPABILITY = "virtual-file-system";
+function createVirtualFileSystem(options) {
+    return new memory_1.InMemoryVirtualFileSystem(options);
+}
+exports.createVirtualFileSystem = createVirtualFileSystem;
+async function openVirtualFileSystem(options) {
+    const storage = options.storage ?? (0, storage_1.createIndexedDbForgeStorage)({ limits: options.limits });
+    const persistedWorkspace = await storage.loadWorkspace(options.workspaceId);
+    return new memory_1.InMemoryVirtualFileSystem({
+        workspaceId: options.workspaceId,
+        workspaceName: persistedWorkspace?.name ?? options.workspaceName ?? "Untitled Workspace",
+        files: persistedWorkspace?.files,
+        metadata: persistedWorkspace?.metadata,
+        lock: persistedWorkspace?.lock,
+        storage,
+        limits: options.limits,
+    });
+}
+exports.openVirtualFileSystem = openVirtualFileSystem;

package/dist/virtual-file-system/limits.d.ts

@@ -0,0 +1,4 @@
+import type { ForgeDiagnostic, ForgeLimitDiagnostic, ForgeVirtualFileSystemLimits, ResolvedForgeVirtualFileSystemLimits } from "./types";
+export declare const DEFAULT_FORGE_VFS_LIMITS: ResolvedForgeVirtualFileSystemLimits;
+export declare function resolveForgeVirtualFileSystemLimits(limits?: ForgeVirtualFileSystemLimits): ResolvedForgeVirtualFileSystemLimits;
+export declare function createLimitExceededDiagnostic(name: ForgeLimitDiagnostic["name"], actual: number, maximum: number, path?: string): ForgeDiagnostic;

package/dist/virtual-file-system/limits.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLimitExceededDiagnostic = exports.resolveForgeVirtualFileSystemLimits = exports.DEFAULT_FORGE_VFS_LIMITS = void 0;
+const diagnostics_1 = require("./diagnostics");
+exports.DEFAULT_FORGE_VFS_LIMITS = {
+    maxFileSizeBytes: 5 * 1024 * 1024,
+    maxWorkspaceSizeBytes: 50 * 1024 * 1024,
+    maxFileCount: 5000,
+    maxPackageCacheSizeBytes: 100 * 1024 * 1024,
+    maxBuildCacheSizeBytes: 100 * 1024 * 1024,
+};
+function resolveForgeVirtualFileSystemLimits(limits = {}) {
+    return {
+        ...exports.DEFAULT_FORGE_VFS_LIMITS,
+        ...limits,
+    };
+}
+exports.resolveForgeVirtualFileSystemLimits = resolveForgeVirtualFileSystemLimits;
+function createLimitExceededDiagnostic(name, actual, maximum, path) {
+    return {
+        ...(0, diagnostics_1.createForgeDiagnostic)({
+            code: "limit_exceeded",
+            message: `Virtual file system limit exceeded: ${name}.`,
+            path,
+        }),
+        limit: {
+            name,
+            actual,
+            maximum,
+        },
+    };
+}
+exports.createLimitExceededDiagnostic = createLimitExceededDiagnostic;

package/dist/virtual-file-system/memory.d.ts

@@ -0,0 +1,33 @@
+import type { ForgeVirtualFileSystem } from "./index";
+import type { ForgeDeleteOptions, ForgeDirEntry, ForgeFileStat, ForgeFileWatchListener, ForgeMkdirOptions, ForgeRestoreOptions, ForgeSnapshot, ForgeSnapshotOptions, ForgeUnsubscribe, ForgeVirtualFileSystemOptions, ForgeWriteFileOptions } from "./types";
+export declare class InMemoryVirtualFileSystem implements ForgeVirtualFileSystem {
+    readonly capability: "virtual-file-system";
+    private readonly workspaceId;
+    private readonly workspaceName;
+    private readonly lock;
+    private readonly storage;
+    private readonly limits;
+    private readonly watchers;
+    private metadata;
+    private records;
+    constructor(options?: ForgeVirtualFileSystemOptions);
+    readFile(path: string): Promise<Uint8Array>;
+    readText(path: string): Promise<string>;
+    writeFile(path: string, content: Uint8Array | string, options?: ForgeWriteFileOptions): Promise<void>;
+    delete(path: string, options?: ForgeDeleteOptions): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    mkdir(path: string, options?: ForgeMkdirOptions): Promise<void>;
+    readdir(path: string): Promise<readonly ForgeDirEntry[]>;
+    stat(path: string): Promise<ForgeFileStat>;
+    exists(path: string): Promise<boolean>;
+    snapshot(options?: ForgeSnapshotOptions): Promise<ForgeSnapshot>;
+    restore(snapshot: ForgeSnapshot, _options?: ForgeRestoreOptions): Promise<void>;
+    watch(listener: ForgeFileWatchListener): ForgeUnsubscribe;
+    private normalize;
+    private requireRecord;
+    private requireFile;
+    private commit;
+    private assertWorkspaceLimits;
+    private assertLimit;
+    private emit;
+}