@zq-silk/yui 0.0.0

package/dist/output/terminal.js

@@ -0,0 +1,198 @@
+const ANSI_PATTERN = /\x1b\[[0-9;]*m/g;
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const RED = "\x1b[31m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const CYAN = "\x1b[36m";
+export function renderSection(title, body) {
+    const normalizedTitle = title.trim();
+    const normalizedBody = body?.trimEnd();
+    if (normalizedBody === undefined || normalizedBody.length === 0)
+        return normalizedTitle;
+    return `${normalizedTitle}\n${normalizedBody.split("\n").map((line) => `  ${line}`).join("\n")}`;
+}
+export function renderDetails(entries) {
+    if (entries.length === 0)
+        return "";
+    const labelWidth = Math.max(...entries.map(([label]) => visibleWidth(label)));
+    return entries.map(([label, value]) => `  ${padVisibleEnd(label, labelWidth)}  ${value.length === 0 ? "—" : value}`).join("\n");
+}
+export function renderCodeBlock(contents) {
+    return contents.trimEnd().split("\n").map((line) => `  │ ${line}`).join("\n");
+}
+export function renderPrompt(question, hint) {
+    const suffix = hint === undefined || hint.length === 0 ? "" : ` [${hint}]`;
+    return `› ${question.trim()}${suffix}: `;
+}
+export function withPromptAnswerSpacing(question, write, inputIsEchoed) {
+    return async (prompt) => {
+        const answer = await question(prompt);
+        write(inputIsEchoed ? "\n" : "\n\n");
+        return answer;
+    };
+}
+export function renderSuccess(message) {
+    return renderOutcome("✓", message);
+}
+export function renderInfo(message) {
+    return renderOutcome("›", message);
+}
+export function renderWarning(message) {
+    return renderOutcome("!", message);
+}
+export function renderError(message) {
+    return renderOutcome("✕", message);
+}
+export function renderEmpty(message) {
+    return renderOutcome("○", message);
+}
+function renderOutcome(symbol, message) {
+    const lines = message.trimEnd().split("\n");
+    return `${lines.map((line, index) => index === 0 ? `${symbol} ${line}` : `  ${line}`).join("\n")}\n`;
+}
+export function terminalSupportsColor(stream, env = process.env) {
+    if (Object.hasOwn(env, "NO_COLOR"))
+        return false;
+    if (env.FORCE_COLOR === "0")
+        return false;
+    if (env.FORCE_COLOR !== undefined)
+        return true;
+    return stream.isTTY === true && env.TERM !== "dumb";
+}
+export function defaultTerminalWidth(stream = process.stdout) {
+    const columns = stream.columns;
+    return columns === undefined || !Number.isFinite(columns) || columns <= 0
+        ? 100
+        : Math.max(20, Math.min(Math.floor(columns), 140));
+}
+export function paintTerminalOutput(output, color) {
+    if (!color || output.length === 0 || ANSI_PATTERN.test(output)) {
+        ANSI_PATTERN.lastIndex = 0;
+        return output;
+    }
+    const lines = output.split("\n");
+    return lines.map((line, index) => paintLine(line, lines, index)).join("\n");
+}
+function paintLine(line, lines, index) {
+    if (line.startsWith("✓ "))
+        return `${GREEN}✓${RESET}${line.slice(1)}`;
+    if (line.startsWith("! "))
+        return `${YELLOW}!${RESET}${line.slice(1)}`;
+    if (line.startsWith("✕ "))
+        return `${RED}✕${RESET}${line.slice(1)}`;
+    if (line.startsWith("› "))
+        return `${CYAN}›${RESET}${line.slice(1)}`;
+    if (line.startsWith("○ "))
+        return `${DIM}${line}${RESET}`;
+    if (/^\s*─+(?:\s+─+)*\s*$/.test(line))
+        return `${DIM}${line}${RESET}`;
+    if (line.startsWith("  │ "))
+        return `  ${DIM}│${RESET}${line.slice(3)}`;
+    if (isHeadingLine(line, lines, index))
+        return `${BOLD}${line}${RESET}`;
+    return line;
+}
+function isHeadingLine(line, lines, index) {
+    if (line.length === 0 || /^\s/.test(line) || /^(?:#|\{|\[)/.test(line))
+        return false;
+    if (/^[A-Z][A-Z0-9_]+: /.test(line) || /^[^:]{1,24}:\s+\S/.test(line))
+        return false;
+    const previousIsBlank = index === 0 || lines[index - 1]?.length === 0;
+    const nextIsBlank = index + 1 < lines.length && lines[index + 1]?.length === 0;
+    return nextIsBlank || previousIsBlank && index === 0;
+}
+export function visibleWidth(value) {
+    const plain = value.replace(ANSI_PATTERN, "");
+    let width = 0;
+    for (const segment of graphemes(plain))
+        width += graphemeWidth(segment);
+    return width;
+}
+export function padVisibleEnd(value, width) {
+    return `${value}${" ".repeat(Math.max(0, width - visibleWidth(value)))}`;
+}
+export function wrapVisibleText(value, width) {
+    const safeWidth = Math.max(1, Math.floor(width));
+    return value.replaceAll("\t", "  ").split("\n")
+        .flatMap((paragraph) => wrapParagraph(paragraph, safeWidth));
+}
+function wrapParagraph(value, width) {
+    if (value.length === 0)
+        return [""];
+    const words = value.trim().split(/\s+/);
+    const lines = [];
+    let current = "";
+    for (const word of words) {
+        for (const chunk of splitVisible(word, width)) {
+            if (current.length === 0) {
+                current = chunk;
+            }
+            else if (visibleWidth(current) + 1 + visibleWidth(chunk) <= width) {
+                current = `${current} ${chunk}`;
+            }
+            else {
+                lines.push(current);
+                current = chunk;
+            }
+        }
+    }
+    if (current.length > 0 || lines.length === 0)
+        lines.push(current);
+    return lines;
+}
+function splitVisible(value, width) {
+    const chunks = [];
+    let chunk = "";
+    let chunkWidth = 0;
+    for (const segment of graphemes(value)) {
+        const segmentWidth = graphemeWidth(segment);
+        if (chunk.length > 0 && chunkWidth + segmentWidth > width) {
+            chunks.push(chunk);
+            chunk = "";
+            chunkWidth = 0;
+        }
+        chunk += segment;
+        chunkWidth += segmentWidth;
+    }
+    if (chunk.length > 0 || chunks.length === 0)
+        chunks.push(chunk);
+    return chunks;
+}
+function graphemes(value) {
+    if (typeof Intl.Segmenter === "function") {
+        return [...new Intl.Segmenter(undefined, { granularity: "grapheme" }).segment(value)]
+            .map(({ segment }) => segment);
+    }
+    return [...value];
+}
+function graphemeWidth(value) {
+    if (value.length === 0)
+        return 0;
+    if (/\p{Extended_Pictographic}/u.test(value))
+        return 2;
+    let width = 0;
+    for (const character of value) {
+        const codePoint = character.codePointAt(0) ?? 0;
+        if (codePoint === 0 || codePoint < 32 || codePoint >= 0x7f && codePoint < 0xa0)
+            continue;
+        if (/\p{Mark}/u.test(character) || codePoint === 0x200d || codePoint >= 0xfe00 && codePoint <= 0xfe0f)
+            continue;
+        width = Math.max(width, isWideCodePoint(codePoint) ? 2 : 1);
+    }
+    return width;
+}
+function isWideCodePoint(codePoint) {
+    return codePoint >= 0x1100 && (codePoint <= 0x115f
+        || codePoint === 0x2329 || codePoint === 0x232a
+        || codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f
+        || codePoint >= 0xac00 && codePoint <= 0xd7a3
+        || codePoint >= 0xf900 && codePoint <= 0xfaff
+        || codePoint >= 0xfe10 && codePoint <= 0xfe19
+        || codePoint >= 0xfe30 && codePoint <= 0xfe6f
+        || codePoint >= 0xff00 && codePoint <= 0xff60
+        || codePoint >= 0xffe0 && codePoint <= 0xffe6
+        || codePoint >= 0x1b000 && codePoint <= 0x1b2ff
+        || codePoint >= 0x20000 && codePoint <= 0x3fffd);
+}

package/dist/repository/gitWorkspace.js

@@ -0,0 +1,210 @@
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { lstat, mkdir, realpath } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { promisify } from "node:util";
+const executeFile = promisify(execFile);
+/** The small Git boundary used by repository registration and Task workspaces. */
+export class NodeGitWorkspace {
+    async inspect(repositoryPath, baseRef = "HEAD") {
+        const requested = await canonicalDirectory(repositoryPath, "Repository");
+        const ref = safeRef(baseRef);
+        const root = await canonicalDirectory(await gitLine(["-C", requested, "rev-parse", "--show-toplevel"]), "Repository root");
+        const gitDirectory = await canonicalDirectory(await gitLine([
+            "-C", root, "rev-parse", "--path-format=absolute", "--git-common-dir"
+        ]), "Git common directory");
+        const baseCommit = await gitLine([
+            "-C", root, "rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`
+        ]);
+        if (!/^[a-f0-9]{40}(?:[a-f0-9]{24})?$/i.test(baseCommit)) {
+            throw new Error("Git returned an invalid base commit.");
+        }
+        return { root, gitDirectory, baseRef: ref, baseCommit: baseCommit.toLowerCase() };
+    }
+    async ensureWorktree(input) {
+        const container = await canonicalContainer(input.container, true);
+        const identity = worktreeIdentity(input.taskId, input.roleName);
+        const path = managedPath(container, identity.directory);
+        const kind = await pathKind(path);
+        if (kind === "symlink")
+            throw new Error("Managed worktree path must not be a symbolic link.");
+        if (kind === "directory") {
+            // A worktree already created before a crash remains usable even if the
+            // original base branch/tag is later deleted.
+            const repository = await this.inspect(input.repositoryPath);
+            await assertOwnedWorktree(repository, container, path);
+            await assertExpectedBranch(path, identity.branch);
+            const head = await gitLine([
+                "-C", path, "rev-parse", "--verify", "--end-of-options", "HEAD^{commit}"
+            ]);
+            return { path, branch: identity.branch, baseCommit: head.toLowerCase() };
+        }
+        const repository = await this.inspect(input.repositoryPath, input.baseRef);
+        await canonicalContainer(dirname(path), true);
+        const branchRef = `refs/heads/${identity.branch}`;
+        const branchExists = await gitSucceeds([
+            "-C", repository.root, "show-ref", "--verify", "--quiet", branchRef
+        ]);
+        await git(branchExists
+            ? ["-C", repository.root, "worktree", "add", "--", path, identity.branch]
+            : [
+                "-C", repository.root, "worktree", "add", "-b", identity.branch,
+                "--", path, repository.baseCommit
+            ]);
+        await assertOwnedWorktree(repository, container, path);
+        await assertExpectedBranch(path, identity.branch);
+        return { path, branch: identity.branch, baseCommit: repository.baseCommit };
+    }
+    async removeWorktree(input) {
+        const container = resolve(input.container);
+        const path = managedPath(container, worktreeIdentity(input.taskId, input.roleName).directory);
+        const kind = await pathKind(path);
+        if (kind === undefined)
+            return "missing";
+        if (kind === "symlink")
+            throw new Error("Managed worktree path must not be a symbolic link.");
+        const canonicalContainerPath = await canonicalContainer(container, false);
+        const repository = await this.inspect(input.repositoryPath);
+        await assertOwnedWorktree(repository, canonicalContainerPath, path);
+        const porcelain = await git(["-C", path, "status", "--porcelain=v1", "--untracked-files=all"]);
+        if (porcelain.length > 0)
+            return "dirty";
+        await git(["-C", repository.root, "worktree", "remove", "--", path]);
+        return "removed";
+    }
+}
+export function worktreeIdentity(taskId, roleName) {
+    const taskKey = safeIdentity(taskId, "Task id");
+    const roleKey = safeIdentity(roleName, "Role name");
+    return {
+        directory: join(taskKey, roleKey),
+        branch: `yui/${gitRefSegment(taskKey)}/${gitRefSegment(roleKey)}`
+    };
+}
+function gitRefSegment(identity) {
+    if (/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(identity)
+        && !identity.includes("..")
+        && !identity.endsWith(".")
+        && !identity.endsWith(".lock")) {
+        return identity;
+    }
+    const digest = createHash("sha256").update(identity).digest("hex").slice(0, 24);
+    return `encoded-${digest}`;
+}
+async function assertExpectedBranch(path, expected) {
+    const branch = await gitLine(["-C", path, "symbolic-ref", "--short", "HEAD"]);
+    if (branch !== expected) {
+        throw new Error(`Managed worktree is on an unexpected branch: ${branch}.`);
+    }
+}
+async function assertOwnedWorktree(repository, container, path) {
+    const canonicalPath = await canonicalDirectory(path, "Managed worktree");
+    assertContained(container, canonicalPath);
+    if (canonicalPath !== path)
+        throw new Error("Managed worktree resolves through a symbolic link.");
+    const root = await canonicalDirectory(await gitLine(["-C", path, "rev-parse", "--show-toplevel"]), "Managed worktree root");
+    if (root !== path)
+        throw new Error("Managed worktree root does not match its deterministic path.");
+    const common = await canonicalDirectory(await gitLine(["-C", path, "rev-parse", "--path-format=absolute", "--git-common-dir"]), "Managed Git common directory");
+    if (common !== repository.gitDirectory) {
+        throw new Error("Managed worktree belongs to another repository.");
+    }
+}
+async function canonicalContainer(path, create) {
+    const lexical = resolve(path);
+    if (create)
+        await mkdir(lexical, { recursive: true, mode: 0o700 });
+    const canonical = await canonicalDirectory(lexical, "Worktree container");
+    if (canonical !== lexical)
+        throw new Error("Worktree container resolves through a symbolic link.");
+    return canonical;
+}
+async function canonicalDirectory(path, label) {
+    const value = requireText(path, label);
+    const canonical = await realpath(isAbsolute(value) ? value : resolve(value));
+    return canonical;
+}
+function managedPath(container, directory) {
+    const path = join(container, directory);
+    assertContained(container, path);
+    return path;
+}
+function assertContained(container, path) {
+    const child = relative(container, path);
+    if (child.length === 0 || child === ".." || child.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) || isAbsolute(child)) {
+        throw new Error("Managed worktree path escapes its container.");
+    }
+}
+async function pathKind(path) {
+    try {
+        const entry = await lstat(path);
+        if (entry.isSymbolicLink())
+            return "symlink";
+        if (!entry.isDirectory())
+            throw new Error("Managed worktree path is not a directory.");
+        return "directory";
+    }
+    catch (error) {
+        if (isErrno(error, "ENOENT"))
+            return undefined;
+        throw error;
+    }
+}
+async function git(args) {
+    try {
+        const result = await executeFile("git", [...args], {
+            encoding: "utf8",
+            maxBuffer: 1024 * 1024,
+            timeout: 30_000
+        });
+        return result.stdout;
+    }
+    catch (error) {
+        const stderr = typeof error === "object" && error !== null && "stderr" in error
+            ? String(error.stderr).trim()
+            : "";
+        throw new Error(stderr.length === 0 ? "Git command failed." : `Git command failed: ${stderr}`, {
+            cause: error
+        });
+    }
+}
+async function gitSucceeds(args) {
+    try {
+        await git(args);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function gitLine(args) {
+    const lines = (await git(args)).trimEnd().split("\n");
+    if (lines.length !== 1 || lines[0]?.length === 0 || lines[0]?.includes("\0")) {
+        throw new Error("Git returned invalid output.");
+    }
+    return lines[0];
+}
+function safeIdentity(value, label) {
+    const identity = requireText(value, label);
+    if ([".", "..", "__proto__", "prototype", "constructor"].includes(identity)
+        || /[\/\\\0]/.test(identity)) {
+        throw new Error(`${label} is invalid.`);
+    }
+    return identity;
+}
+function safeRef(value) {
+    const ref = requireText(value, "Git base ref");
+    if (ref.startsWith("-") || /[\r\n]/.test(ref))
+        throw new Error("Git base ref is invalid.");
+    return ref;
+}
+function requireText(value, label) {
+    if (typeof value !== "string" || value.trim().length === 0 || value.includes("\0")) {
+        throw new Error(`${label} is required.`);
+    }
+    return value.trim();
+}
+function isErrno(value, code) {
+    return typeof value === "object" && value !== null && "code" in value
+        && value.code === code;
+}

package/dist/repository/repository.js

@@ -0,0 +1,55 @@
+import { resolve } from "node:path";
+export function createRepository(id, name, path, defaultBranch, now) {
+    const timestamp = now.toISOString();
+    return validateRepository({
+        schemaVersion: 1,
+        id: requireIdentity(id, "Repository id"),
+        name: requireText(name, "Repository name"),
+        path: resolve(requireText(path, "Repository path")),
+        defaultBranch: requireGitRef(defaultBranch),
+        createdAt: timestamp,
+        updatedAt: timestamp
+    });
+}
+export function validateRepository(repository) {
+    if (repository.schemaVersion !== 1) {
+        throw new Error("Repository must use schemaVersion 1.");
+    }
+    requireIdentity(repository.id, "Repository id");
+    requireText(repository.name, "Repository name");
+    if (resolve(requireText(repository.path, "Repository path")) !== repository.path) {
+        throw new Error("Repository path must be absolute and normalized.");
+    }
+    requireGitRef(repository.defaultBranch);
+    requireTimestamp(repository.createdAt, "Repository createdAt");
+    requireTimestamp(repository.updatedAt, "Repository updatedAt");
+    return repository;
+}
+function requireIdentity(value, label) {
+    const normalized = requireText(value, label);
+    if (["__proto__", "prototype", "constructor", ".", ".."].includes(normalized)
+        || /[\/\\\0]/.test(normalized)) {
+        throw new Error(`${label} is invalid.`);
+    }
+    return normalized;
+}
+function requireGitRef(value) {
+    const ref = requireText(value, "Repository base ref");
+    if (ref.startsWith("-") || /[\r\n]/.test(ref)) {
+        throw new Error("Repository base ref is invalid.");
+    }
+    return ref;
+}
+function requireText(value, label) {
+    if (typeof value !== "string" || value.includes("\0"))
+        throw new Error(`${label} is invalid.`);
+    const normalized = value.trim();
+    if (normalized.length === 0)
+        throw new Error(`${label} is required.`);
+    return normalized;
+}
+function requireTimestamp(value, label) {
+    if (typeof value !== "string" || !Number.isFinite(Date.parse(value))) {
+        throw new Error(`${label} is invalid.`);
+    }
+}