@decohere/devkit 0.0.1-dev.119

package/commonjs/src/interop/shell/shell.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Shell", {
+    enumerable: true,
+    get: function() {
+        return Shell;
+    }
+});
+const _nodechild_process = require("node:child_process");
+const _scribe = require("@decohere/scribe");
+const _interoperror = require("../errors/interop.error.js");
+const _shellargv = require("./shell.argv.js");
+class Shell {
+    async run(options, ...args) {
+        const logger = _scribe.scribe.logger(Shell.name);
+        const argv = args ?? [];
+        const argvFields = _shellargv.shellArgv.fields(argv);
+        const positionals = Array.isArray(argvFields._) ? argvFields._ : [];
+        const commandName = [
+            this.program,
+            ...positionals
+        ].join(" ").trim();
+        logger.info("Running", {
+            program: this.program,
+            args: argvFields
+        });
+        return new Promise((resolve, reject)=>{
+            let settled = false;
+            const resolveOnce = (response)=>{
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                resolve(response);
+            };
+            const rejectOnce = (error)=>{
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                reject(error);
+            };
+            const { cwd, env } = options;
+            const spawnOpt = {
+                cwd: cwd ?? ".",
+                stdio: [
+                    "inherit",
+                    "pipe",
+                    "pipe"
+                ],
+                env: env ?? {
+                    ...process.env
+                }
+            };
+            const proc = (0, _nodechild_process.spawn)(this.program, argv, spawnOpt);
+            const responseData = [];
+            const errorData = [];
+            proc.on("close", (code, signal)=>{
+                if (code === 0) {
+                    resolveOnce({
+                        message: `${commandName} completed`,
+                        data: responseData
+                    });
+                    return;
+                }
+                const stderr = errorData.join("\n").trim();
+                const stdout = responseData.join("\n").trim();
+                const exitCodeText = code == null ? "unknown" : String(code);
+                const signalText = signal ? ` signal ${signal}` : "";
+                const base = `Running '${commandName}' failed with code ${exitCodeText}${signalText}`;
+                const details = [
+                    stderr ? `stderr:\n${stderr}` : "",
+                    !stderr && stdout ? `stdout:\n${stdout}` : ""
+                ].filter(Boolean).join("\n");
+                rejectOnce(new _interoperror.InteropError(details ? `${base}\n${details}` : base));
+            });
+            proc.on("error", (err)=>{
+                rejectOnce(err);
+            });
+            proc.stdout.on("error", (err)=>{
+                rejectOnce(err);
+            });
+            proc.stdout.on("data", (data)=>{
+                const lines = this.parseStream(data);
+                console.log(data.toString());
+                responseData.push(...lines);
+            });
+            proc.stderr?.on("error", (err)=>{
+                rejectOnce(err);
+            });
+            proc.stderr?.on("data", (data)=>{
+                const lines = this.parseStream(data);
+                console.error(data.toString());
+                errorData.push(...lines);
+            });
+        });
+    }
+    parseStream(data) {
+        const dataStr = data.toString();
+        const lines = dataStr.split("\n").filter((l)=>l !== "");
+        return lines;
+    }
+}

package/commonjs/src/interop/shell/shell.types.js

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

package/commonjs/src/interop/types/detect-package-manager.js

@@ -0,0 +1,71 @@
+"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 detectPackageManager () {
+        return detectPackageManager;
+    },
+    get packageManagerFromString () {
+        return packageManagerFromString;
+    },
+    get promptForPackageManager () {
+        return promptForPackageManager;
+    }
+});
+const _nodefs = require("node:fs");
+const _nodepath = require("node:path");
+const _promises = require("node:readline/promises");
+const _npm = require("../npm/npm.js");
+const _pnpm = require("../pnpm/pnpm.js");
+const _yarn = require("../yarn/yarn.js");
+const LOCKFILES = [
+    [
+        "pnpm-lock.yaml",
+        ()=>new _pnpm.Pnpm()
+    ],
+    [
+        "yarn.lock",
+        ()=>new _yarn.Yarn()
+    ],
+    [
+        "package-lock.json",
+        ()=>new _npm.Npm()
+    ]
+];
+function fromLockfile(cwd) {
+    for (const [file, factory] of LOCKFILES){
+        if ((0, _nodefs.existsSync)((0, _nodepath.join)(cwd, file))) return factory();
+    }
+    return undefined;
+}
+function fromUserAgent() {
+    const agent = process.env.npm_config_user_agent ?? "";
+    if (agent.startsWith("pnpm")) return new _pnpm.Pnpm();
+    if (agent.startsWith("yarn")) return new _yarn.Yarn();
+    if (agent.startsWith("npm")) return new _npm.Npm();
+    return undefined;
+}
+function detectPackageManager(cwd) {
+    return fromLockfile(cwd) ?? fromUserAgent();
+}
+function packageManagerFromString(name) {
+    if (name === "yarn") return new _yarn.Yarn();
+    if (name === "npm") return new _npm.Npm();
+    return new _pnpm.Pnpm();
+}
+async function promptForPackageManager() {
+    const rl = (0, _promises.createInterface)({
+        input: process.stdin,
+        output: process.stdout
+    });
+    const answer = await rl.question("Package manager? [pnpm/yarn/npm] (default: pnpm): ");
+    rl.close();
+    return packageManagerFromString(answer.trim().toLowerCase());
+}

package/commonjs/src/interop/types/package-manager.js

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

package/commonjs/src/interop/yarn/yarn.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Yarn", {
+    enumerable: true,
+    get: function() {
+        return Yarn;
+    }
+});
+const _shell = require("../shell/shell.js");
+const Commands = {
+    install: "install"
+};
+class Yarn extends _shell.Shell {
+    name = "yarn";
+    program = "yarn";
+    async install(options = {
+        cwd: "./"
+    }) {
+        const { cwd } = options;
+        return this.run({
+            cwd
+        }, Commands.install);
+    }
+    async syncLockFile(options = {
+        cwd: "./"
+    }) {
+        const { cwd } = options;
+        return this.run({
+            cwd
+        }, Commands.install, "--mode", "update-lockfile", "--ignore-scripts");
+    }
+}

package/commonjs/src/interop/yarn/yarn.types.js

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

package/commonjs/src/io/find-directories.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "findDirectories", {
+    enumerable: true,
+    get: function() {
+        return findDirectories;
+    }
+});
+const _glob = require("glob");
+async function findDirectories(...pattern) {
+    const paths = await (0, _glob.glob)(pattern, {
+        withFileTypes: true
+    });
+    const dirs = paths.filter((p)=>p.isDirectory()).map((p)=>({
+            name: p.name,
+            parentPath: p.parentPath
+        }));
+    return dirs;
+}

package/commonjs/src/io/find-file.js

@@ -0,0 +1,45 @@
+"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 findFile () {
+        return findFile;
+    },
+    get findFiles () {
+        return findFiles;
+    }
+});
+const _glob = require("glob");
+const _io = require("@decohere/core/io");
+async function findFile(pattern) {
+    const files = await (0, _glob.glob)(pattern, {
+        includeChildMatches: false
+    });
+    if (files.length === 0) {
+        return;
+    }
+    const file = {
+        relativePath: files.at(0)
+    };
+    return file;
+}
+async function findFiles(patterns, options) {
+    const paths = await (0, _glob.glob)(patterns, {
+        ...options,
+        withFileTypes: true
+    });
+    const files = paths.filter((p)=>p.isFile()).map((p)=>{
+        return new _io.FileEx({
+            relativePath: p.relative(),
+            fullPath: p.fullpath()
+        });
+    });
+    return files;
+}

package/commonjs/src/io/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./find-directories.js"), exports);
+_export_star(require("./find-file.js"), exports);
+_export_star(require("./watch.js"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/commonjs/src/io/watch.js

@@ -0,0 +1,261 @@
+"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

@@ -0,0 +1,47 @@
+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;
+}