@decohere/devkit 0.0.1-dev.125 → 0.0.1-dev.5

package/commonjs/src/io/watch.js

@@ -1,261 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get WatchEvents () {
-        return WatchEvents;
-    },
-    get watch () {
-        return watch;
-    }
-});
-const _nodefs = require("node:fs");
-const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
-const _picomatch = /*#__PURE__*/ _interop_require_default(require("picomatch"));
-const _io = require("@decohere/core/io");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-const WatchEvents = {
-    add: "add",
-    change: "change",
-    addDir: "addDir",
-    unlink: "unlink",
-    unlinkDir: "unlinkDir"
-};
-function watch(directory, options = {
-    cwd: "."
-}) {
-    const { include, ignore, ignoreInitial = false } = options;
-    const changeCoalesceMs = 25;
-    const handlers = {
-        ready: new Set(),
-        add: new Set(),
-        change: new Set(),
-        addDir: new Set(),
-        unlink: new Set(),
-        unlinkDir: new Set()
-    };
-    let resolveReady;
-    const ready = new Promise((resolve)=>{
-        resolveReady = resolve;
-    });
-    const snapshot = buildSnapshot(directory);
-    const isFiltered = (relativePath)=>{
-        const posixRelativePath = toPosixPath(relativePath);
-        const posixFullPath = toPosixPath(_nodepath.default.resolve(directory, relativePath));
-        const matchesEitherPath = (patterns)=>_picomatch.default.isMatch(posixRelativePath, patterns) || _picomatch.default.isMatch(posixFullPath, patterns);
-        if (include && include.length > 0) {
-            return !matchesEitherPath(include);
-        }
-        if (ignore && ignore.length > 0) {
-            return matchesEitherPath(ignore);
-        }
-        return false;
-    };
-    const emit = (event, relativePath)=>{
-        if (isFiltered(relativePath)) {
-            return;
-        }
-        const fullPath = _nodepath.default.resolve(directory, relativePath);
-        for (const handler of handlers[event]){
-            handler(new _io.FileEx({
-                fullPath,
-                relativePath
-            }));
-        }
-    };
-    const pendingChangeTimers = new Map();
-    const emitChange = (relativePath)=>{
-        const existing = pendingChangeTimers.get(relativePath);
-        if (existing != null) {
-            clearTimeout(existing);
-        }
-        const timer = setTimeout(()=>{
-            pendingChangeTimers.delete(relativePath);
-            emit("change", relativePath);
-        }, changeCoalesceMs);
-        pendingChangeTimers.set(relativePath, timer);
-    };
-    const emitReady = ()=>{
-        for (const handler of handlers.ready){
-            handler();
-        }
-    };
-    queueMicrotask(()=>{
-        if (!ignoreInitial) {
-            for (const [relativePath, entry] of snapshot){
-                emit(entry.isDirectory ? "addDir" : "add", relativePath);
-            }
-        }
-        emitReady();
-        resolveReady?.();
-        resolveReady = undefined;
-    });
-    // One non-recursive watcher per directory. Node's recursive mode on Linux tracks files
-    // individually and goes silent for a file once an editor replaces it with an atomic save
-    // (write temp file, rename over the original); directory watchers keep seeing it (#505).
-    const directoryWatchers = new Map();
-    const watchDirectory = (relativeDir)=>{
-        if (directoryWatchers.has(relativeDir)) {
-            return;
-        }
-        try {
-            const watcher = (0, _nodefs.watch)(_nodepath.default.resolve(directory, relativeDir), (_eventType, fileName)=>{
-                if (fileName != null) {
-                    onFsEvent(_nodepath.default.posix.join(relativeDir, toPosixPath(fileName.toString())));
-                }
-            });
-            watcher.on("error", ()=>unwatchDirectory(relativeDir));
-            directoryWatchers.set(relativeDir, watcher);
-        } catch  {
-        // The directory vanished before we could watch it; its unlink event covers it.
-        }
-    };
-    const unwatchDirectory = (relativeDir)=>{
-        for (const [watchedDir, watcher] of directoryWatchers){
-            if (watchedDir === relativeDir || watchedDir.startsWith(`${relativeDir}/`)) {
-                watcher.close();
-                directoryWatchers.delete(watchedDir);
-            }
-        }
-    };
-    /** A directory appeared: watch it, and report what was created in it before we were watching. */ const addDirectory = (relativeDir)=>{
-        watchDirectory(relativeDir);
-        const found = new Map();
-        try {
-            collectSnapshotEntries(directory, _nodepath.default.resolve(directory, relativeDir), found);
-        } catch  {
-            return;
-        }
-        for (const [relativePath, entry] of found){
-            if (snapshot.has(relativePath)) continue;
-            snapshot.set(relativePath, entry);
-            if (entry.isDirectory) watchDirectory(relativePath);
-            emit(entry.isDirectory ? "addDir" : "add", relativePath);
-        }
-    };
-    /** A directory went away: stop watching it and forget everything that was under it. */ const removeDirectoryContents = (relativeDir)=>{
-        unwatchDirectory(relativeDir);
-        // oxlint-disable-next-line unicorn/no-useless-spread -- iterate a copy: the loop deletes from the snapshot
-        for (const [relativePath, entry] of [
-            ...snapshot
-        ]){
-            if (relativePath.startsWith(`${relativeDir}/`)) {
-                snapshot.delete(relativePath);
-                emit(entry.isDirectory ? "unlinkDir" : "unlink", relativePath);
-            }
-        }
-    };
-    const onFsEvent = (eventPath)=>{
-        const relativePath = eventPath === "." ? "" : eventPath;
-        if (relativePath.length === 0) {
-            return;
-        }
-        const fullPath = _nodepath.default.resolve(directory, relativePath);
-        const previous = snapshot.get(relativePath);
-        try {
-            const stat = (0, _nodefs.statSync)(fullPath);
-            const current = toSnapshotEntry(stat);
-            snapshot.set(relativePath, current);
-            if (previous == null) {
-                emit(current.isDirectory ? "addDir" : "add", relativePath);
-                if (current.isDirectory) addDirectory(relativePath);
-                return;
-            }
-            if (previous.isDirectory !== current.isDirectory) {
-                if (previous.isDirectory) removeDirectoryContents(relativePath);
-                emit(previous.isDirectory ? "unlinkDir" : "unlink", relativePath);
-                emit(current.isDirectory ? "addDir" : "add", relativePath);
-                return;
-            }
-            if (!current.isDirectory && previous.fingerprint !== current.fingerprint) {
-                emitChange(relativePath);
-            }
-        } catch  {
-            if (previous == null) {
-                return;
-            }
-            snapshot.delete(relativePath);
-            const pending = pendingChangeTimers.get(relativePath);
-            if (pending != null) {
-                clearTimeout(pending);
-                pendingChangeTimers.delete(relativePath);
-            }
-            emit(previous.isDirectory ? "unlinkDir" : "unlink", relativePath);
-        }
-    };
-    watchDirectory("");
-    for (const [relativePath, entry] of snapshot){
-        if (entry.isDirectory) watchDirectory(relativePath);
-    }
-    const watchApi = {
-        ready,
-        on (event, handler) {
-            if (event === "ready") {
-                handlers.ready.add(handler);
-                return watchApi;
-            }
-            handlers[event].add(handler);
-            return watchApi;
-        },
-        close: ()=>{
-            for (const pending of pendingChangeTimers.values()){
-                clearTimeout(pending);
-            }
-            pendingChangeTimers.clear();
-            for (const watcher of directoryWatchers.values()){
-                watcher.close();
-            }
-            directoryWatchers.clear();
-        }
-    };
-    return watchApi;
-}
-function buildSnapshot(directoryPath) {
-    const snapshot = new Map();
-    collectSnapshotEntries(directoryPath, directoryPath, snapshot);
-    return snapshot;
-}
-/** Never source, and huge: watching every folder inside them could exhaust OS watch limits. */ const UNWATCHED_DIRECTORIES = new Set([
-    "node_modules",
-    ".git"
-]);
-function collectSnapshotEntries(rootDirectoryPath, currentDirectoryPath, snapshot) {
-    for (const entry of (0, _nodefs.readdirSync)(currentDirectoryPath, {
-        encoding: "utf8"
-    })){
-        const name = typeof entry === "string" ? entry : String(entry);
-        const fullPath = _nodepath.default.join(currentDirectoryPath, name);
-        if (UNWATCHED_DIRECTORIES.has(name)) {
-            continue;
-        }
-        const relativePath = toPosixPath(_nodepath.default.relative(rootDirectoryPath, fullPath));
-        const stat = (0, _nodefs.statSync)(fullPath);
-        const snapshotEntry = toSnapshotEntry(stat);
-        snapshot.set(relativePath, snapshotEntry);
-        if (!snapshotEntry.isDirectory) {
-            continue;
-        }
-        collectSnapshotEntries(rootDirectoryPath, fullPath, snapshot);
-    }
-}
-function toSnapshotEntry(stat) {
-    const isDirectory = stat.isDirectory();
-    return {
-        isDirectory,
-        fingerprint: isDirectory ? `dir:${stat.mtimeMs}` : `file:${stat.mtimeMs}:${stat.size}`
-    };
-}
-function toPosixPath(filePath) {
-    return filePath.split(_nodepath.default.sep).join(_nodepath.default.posix.sep);
-}

package/es6/src/cli/action.js

@@ -1,47 +0,0 @@
-export const ActionMap = Symbol("ActionMap");
-export class ActionResponse {
-    static Success(name, data) {
-        return new ActionResponse({
-            name,
-            data,
-            succeeded: true
-        });
-    }
-    static Skipped(name) {
-        return new ActionResponse({
-            name,
-            skipped: true
-        });
-    }
-    static Blocking(name) {
-        return new ActionResponse({
-            name,
-            succeeded: true,
-            blocking: true
-        });
-    }
-    static Error(name, messageOrData, data) {
-        if (Array.isArray(messageOrData)) {
-            const message = messageOrData.filter((r)=>!r.succeeded).map((r)=>r.error ?? "Unknown error").join("\n");
-            return new ActionResponse({
-                name,
-                message,
-                data: messageOrData
-            });
-        }
-        return new ActionResponse({
-            name,
-            message: messageOrData,
-            data
-        });
-    }
-    constructor(data){
-        Object.assign(this, data);
-    }
-    name;
-    succeeded = false;
-    skipped = false;
-    blocking = false;
-    message;
-    data;
-}

package/es6/src/cli/command.js

@@ -1,106 +0,0 @@
-import { Command as CommanderType } from "commander";
-export const CommandResponse = {
-    success (_ctx, responses) {
-        return responses;
-    },
-    help () {
-        return {};
-    },
-    fromAction (name, response) {
-        return {
-            [name]: response
-        };
-    }
-};
-/** Thrown when a command execution fails due to action errors. */ export class CommandError extends Error {
-}
-export class DecohereCommand extends CommanderType {
-    get actions() {
-        return [];
-    }
-    constructor(name, handler){
-        super();
-        if (typeof name === "string" || typeof name === "function") {
-            this.name(this.parseCommandName(name));
-        } else {
-            this.name(this.parseCommandName(this.constructor));
-            if (name) {
-                this.registerSubcommand(name, handler);
-            }
-        }
-        if (handler && !this.commands.length) {
-            this.action(handler);
-        }
-        this.exitOverride();
-    }
-    /**
-	 * Whether the command, with these options, runs until it is stopped (`flux serve`,
-	 * `forge build --watch`). The CLI then listens for SIGINT and SIGTERM from the moment it
-	 * starts, so a stop during start-up still shuts down cleanly; other commands keep Node's
-	 * default, where Ctrl+C ends them at once.
-	 */ runsUntilStopped(_options) {
-        return false;
-    }
-    async run(actions, options) {
-        const responses = await this.runActions(actions, options);
-        this.throwOnErrors(responses);
-        return CommandResponse.success(options, responses);
-    }
-    registerSubcommand(commands, onAction) {
-        if (typeof commands === "function") {
-            const instance = new commands(commands, onAction);
-            this.addCommand(instance);
-            if (onAction && !instance.commands.length) {
-                instance.action(onAction);
-            }
-            return;
-        }
-        for (const [key, command] of Object.entries(commands)){
-            const instance = command instanceof DecohereCommand ? command : new command(key, onAction);
-            this.addCommand(instance);
-            if (onAction && !instance.commands.length) {
-                instance.action(onAction);
-            }
-        }
-    }
-    async runActions(actions, options) {
-        const selectedActions = this.getSelectedActions(actions);
-        const responses = {};
-        for (const [actionKey, action] of selectedActions){
-            responses[actionKey] = await action.run(options);
-        }
-        return responses;
-    }
-    getSelectedActions(actions) {
-        if (!this.actions.length) {
-            return [];
-        }
-        const actionEntries = Object.entries(actions);
-        return this.actions.map((ActionClass)=>{
-            const selectedAction = actionEntries.find(([, action])=>action instanceof ActionClass);
-            if (!selectedAction) {
-                throw new CommandError(`${this.name()} command missing action instance for ${ActionClass.name}`);
-            }
-            return selectedAction;
-        });
-    }
-    throwOnErrors(responses) {
-        const failures = Object.entries(responses).filter(([, response])=>{
-            if (!response) {
-                return false;
-            }
-            return !response.succeeded && !response.skipped;
-        });
-        if (!failures.length) {
-            return;
-        }
-        throw new CommandError(`${this.name()} command failed. ${failures.map(([actionName, response])=>`${actionName}: ${response?.message ?? "Unknown error"}`).join("\n")}`);
-    }
-    parseCommandName(stringLike) {
-        const command = typeof stringLike === "string" ? stringLike : stringLike.name?.toLowerCase().replace("command", "") ?? "";
-        if (command === "") {
-            throw new CommandError(`Could not parse command name from ${stringLike.toString()}`);
-        }
-        return command;
-    }
-}

package/es6/src/cli/index.js

@@ -1,4 +0,0 @@
-export { ActionMap, ActionResponse } from "./action.js";
-export { CommandError, CommandResponse, DecohereCommand } from "./command.js";
-export { ModuleManifest } from "./module.type.js";
-export { ConfigFileOption, ConfigurationOption, DryRunOption, EnvFileIfExistsOption, EnvFileOption, LogLevelOption, NoBuildOptions, NoCleanOptions, ProjectOption } from "./options.js";

package/es6/src/cli/module.type.js

@@ -1,11 +0,0 @@
-/**
- * Simple declaration interface for a CLI module.
- * Extend this and implement the four abstract members.
- */ export class ModuleManifest {
-    /** Sub-command classes this module contributes. */ commands = {};
-    /** Action classes this module contributes. */ actions = {};
-    /** Register infrastructure services into the DI container. */ registerServices(_builder) {}
-    /** Lazily create a workspace instance. Return null if this module does not use a workspace. */ createWorkspace(_options) {
-        return Promise.resolve(null);
-    }
-}

package/es6/src/cli/options.js

@@ -1,76 +0,0 @@
-import { Option } from "commander";
-function parseOptionalBoolean(input) {
-    if (typeof input === "boolean") {
-        return input;
-    }
-    const value = input.trim().toLowerCase();
-    if ([
-        "true",
-        "1",
-        "yes",
-        "on"
-    ].includes(value)) {
-        return true;
-    }
-    if ([
-        "false",
-        "0",
-        "no",
-        "off"
-    ].includes(value)) {
-        return false;
-    }
-    throw new Error(`Invalid boolean value: "${input}". Use true/false.`);
-}
-export class ConfigurationOption extends Option {
-    constructor(defaultValue){
-        super("--configuration <configuration>", "Configuration name");
-        this.default(defaultValue);
-    }
-}
-export class ConfigFileOption extends Option {
-    constructor(defaultValue = ".decohere.js"){
-        super("--config-file <file>", "Path to Decohere config file");
-        this.default(defaultValue);
-    }
-}
-export class LogLevelOption extends Option {
-    constructor(){
-        super("--log-level <level>", "Log level (trace, debug, info, warn, error)");
-    }
-}
-export class EnvFileOption extends Option {
-    constructor(){
-        super("--env-file <file>", "Load environment variables from this file before running");
-    }
-}
-export class EnvFileIfExistsOption extends Option {
-    constructor(){
-        super("--env-file-if-exists <file>", "Like --env-file, but skip it when the file is missing");
-    }
-}
-export class NoCleanOptions extends Option {
-    constructor(defaultValue){
-        super("--no-clean", "Will not clean the project directories");
-        this.default(defaultValue);
-    }
-}
-export class NoBuildOptions extends Option {
-    constructor(defaultValue){
-        super("--no-build", "Will not run the build step");
-        this.default(defaultValue);
-    }
-}
-export class DryRunOption extends Option {
-    constructor(description, defaultValue = false){
-        super("--dry-run [dryRun]", description);
-        this.default(defaultValue);
-        this.preset(true);
-        this.argParser(parseOptionalBoolean);
-    }
-}
-export class ProjectOption extends Option {
-    constructor(){
-        super("--project <project>", "Project name to target");
-    }
-}

package/es6/src/diagnostics/trace.js

@@ -1,61 +0,0 @@
-import { isPromise } from "node:util/types";
-import { scribe } from "@decohere/scribe";
-/**
- * Trace mode is toggled with FORGE_TRACE, read when a method is decorated. Raising the log level
- * to see the output is the CLI's job at its entry point: importing this module changes nothing.
- */ function isTraceEnabled() {
-    return process.env.FORGE_TRACE != null;
-}
-function serializeArgs(args) {
-    if (args.length === 0) return "";
-    return args.map((arg)=>{
-        if (Array.isArray(arg)) return `[${arg.map(String).join(", ")}]`;
-        const s = String(arg);
-        return s.length > 60 ? `${s.slice(0, 57)}...` : s;
-    }).join(", ");
-}
-function wrapWithTiming(fn, className, methodName, logLevel) {
-    let logger;
-    return function(...args) {
-        if (logger == null) {
-            logger = scribe.logger(className);
-        }
-        const log = logger;
-        const label = `${methodName}(${serializeArgs(args)})`;
-        const start = performance.now();
-        const logDuration = ()=>{
-            log[logLevel](`${label}: ${(performance.now() - start).toFixed(2)}ms`);
-        };
-        const result = fn.apply(this, args);
-        if (isPromise(result)) {
-            return result.finally(logDuration);
-        }
-        logDuration();
-        return result;
-    };
-}
-export function trace(target, propertyKey, descriptor) {
-    if (!isTraceEnabled()) return descriptor;
-    const className = target.constructor.name;
-    descriptor.value = wrapWithTiming(descriptor.value, className, propertyKey, "trace");
-    return descriptor;
-}
-/**
- * Always-on method timing. Logs duration at `info` regardless of `FORGE_TRACE`.
- * Use this to time a specific method without raising the process log level.
- */ export function timed(target, propertyKey, descriptor) {
-    const className = target.constructor.name;
-    descriptor.value = wrapWithTiming(descriptor.value, className, propertyKey, "info");
-    return descriptor;
-}
-export function Trace(constructor) {
-    if (!isTraceEnabled()) return;
-    const className = constructor.name;
-    for (const key of Object.getOwnPropertyNames(constructor.prototype)){
-        if (key === "constructor") continue;
-        const descriptor = Object.getOwnPropertyDescriptor(constructor.prototype, key);
-        if (descriptor == null || typeof descriptor.value !== "function") continue;
-        descriptor.value = wrapWithTiming(descriptor.value, className, key, "trace");
-        Object.defineProperty(constructor.prototype, key, descriptor);
-    }
-}

package/es6/src/interop/docker/docker.js

@@ -1,44 +0,0 @@
-import { InteropError } from "../errors/interop.error.js";
-import { Shell } from "../shell/shell.js";
-export class Docker extends Shell {
-    name = "docker";
-    program = "docker";
-    async build(contextDir, options = {}) {
-        if (contextDir == null || contextDir.trim() === "") {
-            throw new InteropError("Docker build context is required");
-        }
-        const args = [
-            "build"
-        ];
-        if (options.dockerfile) {
-            args.push("-f", options.dockerfile);
-        }
-        for (const tag of options.tags ?? []){
-            args.push("-t", tag);
-        }
-        for (const [key, value] of Object.entries(options.buildArgs ?? {})){
-            args.push("--build-arg", `${key}=${value}`);
-        }
-        for (const [id, env] of Object.entries(options.secrets ?? {})){
-            args.push("--secret", `id=${id},env=${env}`);
-        }
-        if (options.noCache) {
-            args.push("--no-cache");
-        }
-        if (options.pull) {
-            args.push("--pull");
-        }
-        args.push(contextDir);
-        return await this.run({
-            cwd: options.cwd
-        }, ...args);
-    }
-    async push(tag, options = {}) {
-        if (tag == null || tag.trim() === "") {
-            throw new InteropError("Docker tag is required");
-        }
-        return await this.run({
-            cwd: options.cwd
-        }, "push", tag);
-    }
-}

package/es6/src/interop/errors/interop.error.js

@@ -1,2 +0,0 @@
-export class InteropError extends Error {
-}