@sunshaobei/dsh-workflow 0.0.0-stage → 2.1.2

package/vendor/mcode-host/workflow-git-world-read.js

@@ -0,0 +1,183 @@
+// Ported unchanged logic from MCode bootstrap/src/app/workflow-git-world-read.ts. Only runtime import paths adapted.
+import { WorkflowError } from "../dynamic-workflow/index.js";
+const GIT_REF_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._/@^~-]*$/;
+export const GIT_LOG_PRETTY = "--pretty=format:%H%x00%s%x00%an%x00%aI";
+export const GIT_SHOW_PREFIX_ARGV = ["rev-parse", "--show-prefix"];
+export const GIT_STATUS_ARGV = [
+    "status",
+    "--porcelain=v2",
+    "-z",
+    "--branch",
+    "--",
+    ".",
+];
+export const GIT_UNTRACKED_ARGV = [
+    "ls-files",
+    "--others",
+    "--exclude-standard",
+    "-z",
+    "--full-name",
+    "--",
+    ".",
+];
+const WORKSPACE_PATHSPEC = ".";
+function validateGitRef(op, value) {
+    if (value.length === 0) {
+        throw new WorkflowError("DriverError", `world-read ${op}: base must not be empty. Pass a ref such as "main" or omit it.`);
+    }
+    if (value.startsWith("-")) {
+        throw new WorkflowError("DriverError", `world-read ${op}: base '${value}' starts with '-', which git would read as an option, ` +
+            `not a ref. Pass a plain ref.`);
+    }
+    if (value.includes("..")) {
+        throw new WorkflowError("DriverError", `world-read ${op}: base '${value}' is a '..' range; only a single ref is accepted. Pass ` +
+            `one ref.`);
+    }
+    if (!GIT_REF_PATTERN.test(value)) {
+        throw new WorkflowError("DriverError", `world-read ${op}: base '${value}' is not a valid ref. A ref starts with a letter or ` +
+            `digit, followed by letters, digits and . _ / @ ^ ~ - (no whitespace or syntax ` +
+            `characters such as {} :).`);
+    }
+    return value;
+}
+function validateGitPath(op, value) {
+    if (value.length === 0) {
+        throw new WorkflowError("DriverError", `world-read ${op}: path must not be empty. Pass a workspace-relative path or omit it.`);
+    }
+    if (value.startsWith("-")) {
+        throw new WorkflowError("DriverError", `world-read ${op}: path '${value}' starts with '-', which git could read as an option. ` +
+            `Pass a path that does not start with '-'.`);
+    }
+    if (looksAbsolute(value)) {
+        throw new WorkflowError("DriverError", `world-read ${op}: path '${value}' is absolute; only workspace-relative paths are ` +
+            `accepted. Pass the path relative to the workspace root.`);
+    }
+    const normalized = value.replace(/\\/g, "/");
+    if (normalized.split("/").includes("..")) {
+        throw new WorkflowError("DriverError", `world-read ${op}: path '${value}' contains a '..' segment and would leave the ` +
+            `workspace. Pass a path inside the workspace.`);
+    }
+    return normalized;
+}
+function looksAbsolute(value) {
+    return value.startsWith("/") || value.startsWith("\\") || /^[A-Za-z]:[\\/]?/.test(value);
+}
+export function gitChangedFilesPlan(base) {
+    const ref = base === undefined ? "HEAD" : validateGitRef("git-changed-files", base);
+    const tracked = {
+        argv: ["diff", "--name-only", "-z", ref, "--", WORKSPACE_PATHSPEC],
+    };
+    if (base !== undefined)
+        return [tracked];
+    return [tracked, { argv: [...GIT_UNTRACKED_ARGV] }];
+}
+export function gitDiffArgv(base, path) {
+    const ref = base === undefined ? "HEAD" : validateGitRef("git-diff", base);
+    const pathspec = path === undefined ? WORKSPACE_PATHSPEC : validateGitPath("git-diff", path);
+    return ["diff", "--relative", ref, "--", pathspec];
+}
+export function gitLogArgv(count) {
+    return ["log", `-n${count}`, GIT_LOG_PRETTY];
+}
+export function parseGitShowPrefix(stdout) {
+    return stdout.replace(/\r?\n$/, "");
+}
+function nulSegments(stdout) {
+    return stdout.split("\u0000").filter((segment) => segment.length > 0);
+}
+function stripWorkspacePrefix(prefix, path) {
+    if (prefix.length === 0)
+        return path;
+    if (path.startsWith(prefix))
+        return path.slice(prefix.length);
+    throw new WorkflowError("DriverError", `git reported path '${path}' outside the workspace prefix '${prefix}'. The pathspec should ` +
+        `have scoped the read to the workspace, so the scoping is broken; report this as a bug.`);
+}
+export function parseGitStatusPorcelainV2(stdout, prefix = "") {
+    const staged = [];
+    const unstaged = [];
+    const untracked = [];
+    let branch;
+    const segments = nulSegments(stdout);
+    for (let index = 0; index < segments.length; index += 1) {
+        const segment = segments[index];
+        if (segment.startsWith("# branch.head ")) {
+            const head = segment.slice("# branch.head ".length);
+            if (head !== "(detached)")
+                branch = head;
+            continue;
+        }
+        if (segment.startsWith("#"))
+            continue;
+        const kind = segment[0];
+        if (kind === "1" || kind === "2") {
+            const xy = segment.split(" ")[1] ?? "..";
+            const path = fieldTail(segment, kind === "1" ? 8 : 9);
+            if (kind === "2")
+                index += 1;
+            if (path.length === 0)
+                continue;
+            const relative = stripWorkspacePrefix(prefix, path);
+            if (xy[0] !== undefined && xy[0] !== ".")
+                staged.push(relative);
+            if (xy[1] !== undefined && xy[1] !== ".")
+                unstaged.push(relative);
+            continue;
+        }
+        if (kind === "u") {
+            const path = fieldTail(segment, 10);
+            if (path.length > 0)
+                unstaged.push(stripWorkspacePrefix(prefix, path));
+            continue;
+        }
+        if (kind === "?") {
+            const path = fieldTail(segment, 1);
+            if (path.length > 0)
+                untracked.push(stripWorkspacePrefix(prefix, path));
+        }
+    }
+    const clean = staged.length === 0 && unstaged.length === 0 && untracked.length === 0;
+    return {
+        ...(branch === undefined ? {} : { branch }),
+        clean,
+        staged: sortedUnique(staged),
+        unstaged: sortedUnique(unstaged),
+        untracked: sortedUnique(untracked),
+    };
+}
+export function parseGitLog(stdout) {
+    const commits = [];
+    for (const raw of stdout.split("\n")) {
+        const record = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+        if (record.length === 0)
+            continue;
+        const fields = record.split("\u0000");
+        if (fields.length !== 4) {
+            throw new WorkflowError("DriverError", `world-read git-log: cannot parse the output; a record should have 4 NUL-separated ` +
+                `fields, got ${fields.length}. Retry, and report this as a bug if it persists.`);
+        }
+        commits.push({
+            hash: fields[0],
+            subject: fields[1],
+            author: fields[2],
+            date: fields[3],
+        });
+    }
+    return commits;
+}
+export function parseGitPathList(stdout, prefix = "") {
+    return nulSegments(stdout).map((path) => stripWorkspacePrefix(prefix, path));
+}
+function fieldTail(line, index) {
+    let at = 0;
+    for (let i = 0; i < index; i += 1) {
+        const next = line.indexOf(" ", at);
+        if (next === -1)
+            return "";
+        at = next + 1;
+    }
+    return line.slice(at);
+}
+function sortedUnique(values) {
+    return [...new Set(values)].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+}

package/vendor/mcode-host/workflow-world-read.js

@@ -0,0 +1,282 @@
+// Ported unchanged logic from MCode bootstrap/src/app/workflow-world-read.ts. Only runtime import paths adapted.
+import { isAbsolute as isAbsolutePath, relative as relativePath, resolve as resolvePath, sep, } from "node:path";
+import { WORLD_READ_CAPS, WorkflowError } from "../dynamic-workflow/index.js";
+import { GIT_SHOW_PREFIX_ARGV, GIT_STATUS_ARGV, gitChangedFilesPlan, gitDiffArgv, gitLogArgv, parseGitLog, parseGitPathList, parseGitShowPrefix, parseGitStatusPorcelainV2, } from "./workflow-git-world-read.js";
+export async function executeWorldRead(deps, op, args) {
+    switch (op) {
+        case "glob":
+            return await worldGlob(deps, worldReadStringArgs(op, args, ["pattern"])[0]);
+        case "read":
+            return await worldRead(deps, worldReadStringArgs(op, args, ["path"])[0]);
+        case "grep": {
+            const [pattern, glob] = worldReadOptionalStringArgs(op, args, ["pattern"], ["glob"]);
+            return await worldGrep(deps, pattern, glob);
+        }
+        case "git-changed-files": {
+            const [base] = worldReadOptionalStringArgs(op, args, [], ["base"]);
+            return await gitChangedFiles(deps, base);
+        }
+        case "git-diff": {
+            const [base, path] = worldReadOptionalStringArgs(op, args, [], ["base", "path"]);
+            return await gitDiff(deps, base, path);
+        }
+        case "git-status": {
+            worldReadStringArgs(op, args, []);
+            return await gitStatus(deps);
+        }
+        case "git-log":
+            return await gitLog(deps, worldReadOptionalCount(op, args, "count"));
+        case "run":
+            return await worldRun(deps, args);
+        default: {
+            const unknownOp = op;
+            throw new WorkflowError("DriverError", `Unsupported world-read op "${String(unknownOp)}".`);
+        }
+    }
+}
+async function worldGlob(deps, pattern) {
+    const cap = WORLD_READ_CAPS.globMaxFiles;
+    const result = await deps.fileSystemPort.searchFiles({
+        path: deps.cwd,
+        pattern,
+        maxResults: cap + 1,
+    });
+    if (result.files.length > cap || result.truncated) {
+        throw capExceeded(`files.glob: over ${cap} files match (the cap). Narrow the pattern.`);
+    }
+    return result.files.map((path) => toWorkspaceRelative(deps.cwd, path)).sort();
+}
+async function worldRead(deps, arg) {
+    const path = assertWithinWorkspace("read", deps.cwd, arg);
+    const result = await deps.fileSystemPort.readTextFile({ path });
+    return result.content;
+}
+async function worldGrep(deps, pattern, glob) {
+    const cap = WORLD_READ_CAPS.grepMaxMatches;
+    const result = await deps.fileSystemPort.searchText({
+        path: deps.cwd,
+        pattern,
+        ...(glob === undefined ? {} : { glob }),
+        outputMode: "content",
+        showLineNumbers: true,
+        headLimit: cap + 1,
+    });
+    if (result.entries.length > cap || result.truncated) {
+        throw capExceeded(`files.grep: over ${cap} matches (the cap). Narrow the pattern or add a glob.`);
+    }
+    const matches = [];
+    for (const entry of result.entries) {
+        if (entry.lineNumber === undefined || entry.text === undefined)
+            continue;
+        matches.push({
+            path: toWorkspaceRelative(deps.cwd, entry.path),
+            line: entry.lineNumber,
+            text: entry.text,
+        });
+    }
+    const serializedBytes = Buffer.byteLength(JSON.stringify(matches), "utf8");
+    if (serializedBytes > WORLD_READ_CAPS.grepMaxSerializedBytes) {
+        throw capExceeded(`files.grep: result is ${serializedBytes} bytes, over the ` +
+            `${WORLD_READ_CAPS.grepMaxSerializedBytes}-byte cap. Narrow the pattern or add a glob.`);
+    }
+    return matches;
+}
+async function runGit(deps, op, argv, maxInlineBytes) {
+    const result = await deps.executionPort.run({
+        command: { mode: "argv", file: "git", args: [...argv] },
+        cwd: deps.cwd,
+        outputLimit: { maxInlineBytes },
+    });
+    if (result.status !== "completed" || (result.exitCode ?? 0) !== 0) {
+        const detail = firstLine(result.stderr.text) || firstLine(result.stdout.text) || result.status;
+        throw new WorkflowError("DriverError", `git ${argv.join(" ")} failed (${result.status}, exit=${result.exitCode ?? "n/a"}): ${detail}`);
+    }
+    return {
+        text: result.stdout.text,
+        bytes: result.stdout.bytes,
+        truncated: result.stdout.truncated,
+    };
+}
+async function gitWorkspacePrefix(deps, op) {
+    const out = await runGit(deps, op, GIT_SHOW_PREFIX_ARGV, GIT_TEXT_OUTPUT_BYTES);
+    return parseGitShowPrefix(out.text);
+}
+async function gitChangedFiles(deps, base) {
+    const plans = gitChangedFilesPlan(base);
+    const prefix = await gitWorkspacePrefix(deps, "git-changed-files");
+    const paths = [];
+    for (const plan of plans) {
+        const out = await runGit(deps, "git-changed-files", plan.argv, GIT_TEXT_OUTPUT_BYTES);
+        paths.push(...parseGitPathList(out.text, prefix));
+    }
+    return [...new Set(paths)].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+}
+async function gitDiff(deps, base, path) {
+    const cap = WORLD_READ_CAPS.gitDiffMaxBytes;
+    const out = await runGit(deps, "git-diff", gitDiffArgv(base, path), cap + 1);
+    if (out.bytes > cap || out.truncated) {
+        throw capExceeded(`git.diff: output is ${out.bytes} bytes, over the ${cap}-byte cap. Pass a path to narrow.`);
+    }
+    return out.text;
+}
+async function gitStatus(deps) {
+    const prefix = await gitWorkspacePrefix(deps, "git-status");
+    const out = await runGit(deps, "git-status", GIT_STATUS_ARGV, GIT_TEXT_OUTPUT_BYTES);
+    return parseGitStatusPorcelainV2(out.text, prefix);
+}
+async function gitLog(deps, count) {
+    const out = await runGit(deps, "git-log", gitLogArgv(count), GIT_TEXT_OUTPUT_BYTES);
+    return parseGitLog(out.text);
+}
+async function worldRun(deps, args) {
+    const { argv, cmd, timeoutMs } = worldRunArgs(args);
+    const stdoutCap = WORLD_READ_CAPS.runStdoutMaxBytes;
+    const stderrCap = WORLD_READ_CAPS.runStderrMaxBytes;
+    const result = await deps.executionPort.run({
+        command: { mode: "argv", file: cmd, args: argv },
+        cwd: deps.cwd,
+        timeoutMs,
+        outputLimit: { maxInlineBytes: Math.max(stdoutCap, stderrCap) + 1 },
+    });
+    if (result.status === "timed_out") {
+        throw new WorkflowError("DriverError", `world.run '${cmd}' timed out after ${timeoutMs}ms. Raise opts.timeoutMs or narrow the work.`);
+    }
+    const ranToExit = result.status === "completed" ||
+        (result.status === "failed" &&
+            result.error === undefined &&
+            typeof result.exitCode === "number");
+    if (!ranToExit) {
+        const detail = result.error?.message ?? (firstLine(result.stderr.text) || result.status);
+        throw new WorkflowError("DriverError", `world.run '${cmd}' did not run to completion (${result.status}): ${detail}`);
+    }
+    if (result.stdout.bytes > stdoutCap || result.stdout.truncated) {
+        throw capExceeded(`world.run '${cmd}': stdout is ${result.stdout.bytes} bytes, over the ${stdoutCap}-byte cap. ` +
+            `Quiet the output (e.g. --quiet), or write a file and files.read a summary.`);
+    }
+    if (result.stderr.bytes > stderrCap || result.stderr.truncated) {
+        throw capExceeded(`world.run '${cmd}': stderr is ${result.stderr.bytes} bytes, over the ${stderrCap}-byte cap. ` +
+            `Reduce the diagnostics, or write a file and files.read a summary.`);
+    }
+    return {
+        exitCode: result.exitCode ?? 0,
+        stdout: result.stdout.text,
+        stderr: result.stderr.text,
+    };
+}
+function worldRunArgs(args) {
+    if (args.length < 1 || args.length > 3) {
+        throw new WorkflowError("DriverError", `world.run takes 1 to 3 arguments (cmd, args?, opts?), got ${args.length}.`);
+    }
+    const cmd = requireStringArg("run", args[0], "cmd", 0);
+    const rawArgv = args[1];
+    let argv = [];
+    if (rawArgv !== undefined) {
+        if (!Array.isArray(rawArgv)) {
+            throw new WorkflowError("DriverError", `world.run: argument 2 (args) must be an array of strings, got ${describeArg(rawArgv)}.`);
+        }
+        argv = rawArgv.map((item, index) => {
+            if (typeof item !== "string") {
+                throw new WorkflowError("DriverError", `world.run: args[${index}] must be a string, got ${describeArg(item)}. Stringify values.`);
+            }
+            return item;
+        });
+    }
+    const rawOpts = args[2];
+    let timeoutMs = WORLD_READ_CAPS.runDefaultTimeoutMs;
+    if (rawOpts !== undefined) {
+        if (typeof rawOpts !== "object" || rawOpts === null || Array.isArray(rawOpts)) {
+            throw new WorkflowError("DriverError", `world.run: arg 3 (opts) must be an options object or omitted, got ${describeArg(rawOpts)}.`);
+        }
+        const rawTimeout = rawOpts.timeoutMs;
+        if (rawTimeout !== undefined) {
+            if (typeof rawTimeout !== "number" || !Number.isInteger(rawTimeout) || rawTimeout < 1) {
+                throw new WorkflowError("DriverError", `world.run: opts.timeoutMs must be an integer >= 1, got ${describeArg(rawTimeout)}.`);
+            }
+            timeoutMs = rawTimeout;
+        }
+    }
+    return { argv, cmd, timeoutMs };
+}
+function worldReadStringArgs(op, args, names) {
+    if (args.length !== names.length) {
+        throw new WorkflowError("DriverError", `world-read ${op} takes ${names.length} arguments (${names.join(", ")}), got ${args.length}.`);
+    }
+    return names.map((name, index) => requireStringArg(op, args[index], name, index));
+}
+function worldReadOptionalStringArgs(op, args, required, optional) {
+    const max = required.length + optional.length;
+    if (args.length < required.length || args.length > max) {
+        const range = required.length === max ? `${max}` : `${required.length}~${max}`;
+        throw new WorkflowError("DriverError", `world-read ${op} takes ${range} arguments ` +
+            `(${[...required, ...optional.map((n) => `${n}?`)].join(", ")}), got ${args.length}.`);
+    }
+    const out = [];
+    required.forEach((name, index) => out.push(requireStringArg(op, args[index], name, index)));
+    optional.forEach((name, offset) => {
+        const index = required.length + offset;
+        if (index >= args.length) {
+            out.push(undefined);
+            return;
+        }
+        const value = args[index];
+        if (value === undefined) {
+            out.push(undefined);
+            return;
+        }
+        out.push(requireStringArg(op, value, name, index));
+    });
+    return out;
+}
+function worldReadOptionalCount(op, args, name) {
+    const max = WORLD_READ_CAPS.gitLogMaxCount;
+    if (args.length > 1) {
+        throw new WorkflowError("DriverError", `world-read ${op} takes at most 1 argument (${name}?), got ${args.length}.`);
+    }
+    const raw = args[0];
+    if (raw === undefined)
+        return WORLD_READ_CAPS.gitLogDefaultCount;
+    if (typeof raw !== "number" || !Number.isInteger(raw) || raw < 1) {
+        throw new WorkflowError("DriverError", `world-read ${op}: argument '${name}' must be an integer >= 1, got ${describeArg(raw)}.`);
+    }
+    if (raw > max) {
+        throw new WorkflowError("DriverError", `world-read ${op}: argument '${name}'=${raw} is over the cap of ${max}; pass at most ${max}.`);
+    }
+    return raw;
+}
+function requireStringArg(op, value, name, index) {
+    if (typeof value !== "string") {
+        throw new WorkflowError("DriverError", `world-read ${op}: arg ${index + 1} (${name}) must be a string, got ${describeArg(value)}.`);
+    }
+    return value;
+}
+function capExceeded(message) {
+    return new WorkflowError("WorldReadCapExceeded", message);
+}
+export function resolveWithinWorkspace(cwd, arg) {
+    const resolved = resolvePath(cwd, arg);
+    const rel = relativePath(cwd, resolved);
+    const escapes = rel === ".." || rel.startsWith(`..${sep}`) || rel.startsWith("../");
+    return escapes || isAbsolutePath(rel) ? undefined : resolved;
+}
+function assertWithinWorkspace(op, cwd, arg) {
+    const resolved = resolveWithinWorkspace(cwd, arg);
+    if (resolved === undefined) {
+        throw new WorkflowError("DriverError", `world-read ${op}: path '${arg}' is outside the workspace; pass a path inside it.`);
+    }
+    return resolved;
+}
+export function toWorkspaceRelative(cwd, path) {
+    const rel = resolvePath(cwd, path) === path ? relativePath(cwd, path) : path;
+    return rel.replace(/\\/g, "/");
+}
+function firstLine(text) {
+    return text.split("\n", 1)[0]?.trim() ?? "";
+}
+const GIT_TEXT_OUTPUT_BYTES = 4 * 1024 * 1024;
+function describeArg(value) {
+    if (value === undefined)
+        return "undefined";
+    if (value === null)
+        return "null";
+    return Array.isArray(value) ? "array" : typeof value;
+}