@zq-silk/yui 0.2.0 → 0.4.2

package/dist/commands/repositoryCommands.js

@@ -1,86 +0,0 @@
-import { usageError } from "../errors/cliError.js";
-import { defaultTableWidth, renderTable } from "../output/table.js";
-import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
-import { createRepository } from "../repository/repository.js";
-export async function runRepositoryCommand(args, store, options = {}) {
-    const [command, ...rest] = args;
-    if (command === "add")
-        return addRepository(rest, store, options);
-    if (command === "list")
-        return listRepositories(rest, store);
-    throw usageError(command === undefined
-        ? "Repository command is required."
-        : `Unknown command: repository ${command}`);
-}
-async function addRepository(args, store, options) {
-    const usage = "Repository add usage: yui repository add <name> <path> [--base <ref>].";
-    const parsed = parseAddArguments(args, usage);
-    const git = options.git ?? new NodeGitWorkspace();
-    const inspected = await git.inspect(parsed.path, parsed.baseRef ?? "HEAD");
-    const repository = createRepository(store.nextRepositoryId(), parsed.name, inspected.root, parsed.baseRef ?? inspected.baseRef, (options.now ?? (() => new Date()))());
-    if (store.listRepositories().some((entry) => entry.path === repository.path)) {
-        throw usageError(`Repository path is already registered: ${repository.path}.`);
-    }
-    const created = store.createRepositoryIfAbsent(repository);
-    if (created === null)
-        throw usageError(`Repository already exists: ${repository.name}.`);
-    return [
-        `Added repository ${created.id}`,
-        `Name: ${created.name}`,
-        `Path: ${created.path}`,
-        `Base: ${created.defaultBranch}`
-    ].join("\n").concat("\n");
-}
-function listRepositories(args, store) {
-    if (args.length !== 0) {
-        throw usageError("Repository list usage: yui repository list.");
-    }
-    const repositories = store.listRepositories();
-    if (repositories.length === 0)
-        return "No repositories found.\n";
-    return `${renderTable("Repositories", [
-        { header: "Repository", minWidth: 10, maxWidth: 24 },
-        { header: "Name", minWidth: 4, maxWidth: 28 },
-        { header: "Path", minWidth: 8, maxWidth: 64 },
-        { header: "Base", minWidth: 4, maxWidth: 24 }
-    ], repositories.map((repository) => [
-        repository.id,
-        repository.name,
-        repository.path,
-        repository.defaultBranch
-    ]), defaultTableWidth())}\n`;
-}
-function parseAddArguments(args, usage) {
-    const positionals = [];
-    let baseRef;
-    for (let index = 0; index < args.length; index += 1) {
-        const value = args[index];
-        if (value === "--base") {
-            if (baseRef !== undefined)
-                throw usageError(`--base may only be provided once. ${usage}`);
-            const next = args[index + 1];
-            if (next === undefined || next.startsWith("--"))
-                throw usageError(`--base is required. ${usage}`);
-            baseRef = requireText(next, "--base");
-            index += 1;
-            continue;
-        }
-        if (value.startsWith("--"))
-            throw usageError(`Unknown option: ${value}. ${usage}`);
-        positionals.push(value);
-    }
-    if (positionals.length !== 2)
-        throw usageError(usage);
-    return {
-        name: requireText(positionals[0], "Repository name"),
-        path: requireText(positionals[1], "Repository path"),
-        ...(baseRef === undefined ? {} : { baseRef })
-    };
-}
-function requireText(value, label) {
-    const normalized = value.trim();
-    if (normalized.length === 0 || normalized.includes("\0")) {
-        throw usageError(`${label} is required.`);
-    }
-    return normalized;
-}

package/dist/operator/operatorContext.js

@@ -1,66 +0,0 @@
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { SYSTEM_OPERATOR_ROLE } from "../role/systemRoles.js";
-/**
- * Prepares durable Operator instructions without turning them into Codex's
- * positional first prompt. Interactive Operator entry must open at the native
- * Agent composer; launch code can pass systemPrompt through an adapter-native
- * instruction channel when one is available.
- */
-export function prepareGlobalRoleLaunch(role, options = {}) {
-    const args = [...(role.args ?? [])];
-    const base = mergeEnv(options.baseEnv, role.env ?? {});
-    if (role.name !== SYSTEM_OPERATOR_ROLE || options.yuiHome === undefined) {
-        return { args, env: base };
-    }
-    const contextPath = writeOperatorContext(options.yuiHome, role.workspace);
-    return {
-        args,
-        env: mergeEnv(base, {
-            YUI_HOME: options.yuiHome,
-            YUI_ROLE: role.name,
-            YUI_WORKSPACE: role.workspace,
-            YUI_OPERATOR_CONTEXT: contextPath
-        }),
-        systemPrompt: renderOperatorLaunchInstruction(contextPath),
-        contextPath
-    };
-}
-export function writeOperatorContext(yuiHome, workspace) {
-    const operatorDir = join(yuiHome, "operator");
-    const contextPath = join(operatorDir, "YUI_OPERATOR.md");
-    mkdirSync(operatorDir, { recursive: true });
-    writeFileSync(contextPath, `${renderOperatorContext(yuiHome, workspace)}\n`, { mode: 0o600 });
-    return contextPath;
-}
-export function renderOperatorLaunchInstruction(contextPath) {
-    return [
-        `Read and follow the Yui Operator instructions in ${contextPath}.`,
-        "Manage Yui through its CLI; do not perform Task work."
-    ].join(" ");
-}
-function renderOperatorContext(yuiHome, workspace) {
-    return `${readOperatorSkill()}
-
-# Yui Operator runtime
-
-You are the Yui Operator. Act as the user's CLI proxy and manage Yui without performing Task work.
-
-Rules:
-
-- Use Yui commands to create and inspect Tasks, manage global and Task Roles, choose Agents, and submit user input.
-- Do not edit files under YUI_HOME directly.
-- Every Task has a protected leader Role; Operator is global and never acts as a Task Leader or Worker.
-- Keep native Agent session interaction intact. Do not emulate Agent slash commands or terminal input.
-
-Environment:
-
-- YUI_HOME=${yuiHome}
-- YUI_WORKSPACE=${workspace}`;
-}
-function readOperatorSkill() {
-    return readFileSync(new URL("../../skills/yui-operator/SKILL.md", import.meta.url), "utf8").trim();
-}
-function mergeEnv(baseEnv = process.env, roleEnv) {
-    return { ...baseEnv, ...roleEnv };
-}

package/dist/repository/repository.js

@@ -1,55 +0,0 @@
-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.`);
-    }
-}

package/dist/scheduler/archivedTaskRuntime.js

@@ -1,12 +0,0 @@
-/** Stops archived Task processes at the tmux boundary and closes their sessions. */
-export async function stopArchivedTaskRuntimes(store, delivery, now) {
-    const stopped = [];
-    for (const task of store.listTasks()) {
-        if (task.status !== "archived")
-            continue;
-        if (await delivery.stopTask(task.id))
-            stopped.push(task.id);
-        store.saveArchivedTaskStopped(task.id, now);
-    }
-    return stopped;
-}

package/dist/worktree/roleWorkspace.js

@@ -1,62 +0,0 @@
-import { resolve } from "node:path";
-export function createRoleWorkspace(input, now) {
-    const timestamp = now.toISOString();
-    return validateRoleWorkspace({
-        schemaVersion: 1,
-        taskId: requireIdentity(input.taskId, "Task id"),
-        roleName: requireIdentity(input.roleName, "Role name"),
-        repositoryId: requireIdentity(input.repositoryId, "Repository id"),
-        path: resolve(requireText(input.path, "Role workspace path")),
-        branch: requireText(input.branch, "Role workspace branch"),
-        baseRef: requireText(input.baseRef, "Role workspace base ref"),
-        baseCommit: requireCommit(input.baseCommit),
-        createdAt: timestamp,
-        updatedAt: timestamp
-    });
-}
-export function validateRoleWorkspace(workspace) {
-    if (workspace.schemaVersion !== 1) {
-        throw new Error("RoleWorkspace must use schemaVersion 1.");
-    }
-    requireIdentity(workspace.taskId, "Task id");
-    requireIdentity(workspace.roleName, "Role name");
-    requireIdentity(workspace.repositoryId, "Repository id");
-    if (resolve(requireText(workspace.path, "Role workspace path")) !== workspace.path) {
-        throw new Error("Role workspace path must be absolute and normalized.");
-    }
-    requireText(workspace.branch, "Role workspace branch");
-    requireText(workspace.baseRef, "Role workspace base ref");
-    requireCommit(workspace.baseCommit);
-    requireTimestamp(workspace.createdAt, "RoleWorkspace createdAt");
-    requireTimestamp(workspace.updatedAt, "RoleWorkspace updatedAt");
-    return workspace;
-}
-function requireIdentity(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 requireCommit(value) {
-    const commit = requireText(value, "Role workspace base commit").toLowerCase();
-    if (!/^[a-f0-9]{40}(?:[a-f0-9]{24})?$/.test(commit)) {
-        throw new Error("Role workspace base commit is invalid.");
-    }
-    return commit;
-}
-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.`);
-    }
-}