@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/git/streaming-batch.js

@@ -1,354 +0,0 @@
-import { isFullGitObjectId } from "./core.js";
-import { openGitProcess, terminateGitChild, } from "./process.js";
-/** Default long-lived batch argv. One-shot calls must not use this gate. */
-export const GIT_STREAMING_BATCH_DEFAULT_ARGS = ["cat-file", "--batch"];
-/** Safety cap for a single response header line before the body frame. */
-export const GIT_STREAMING_BATCH_MAX_HEADER_BYTES = 64 * 1024;
-/** Wire/framing failure while reading batch stdout. */
-export class GitStreamingBatchFramingError extends Error {
-    name = "GitStreamingBatchFramingError";
-}
-/** Stdout ended before a complete frame arrived. */
-export class GitStreamingBatchResponseEndedError extends Error {
-    name = "GitStreamingBatchResponseEndedError";
-}
-class BufferedReader {
-    #iterator;
-    #onProgress;
-    #buffer = Buffer.alloc(0);
-    #ended = false;
-    constructor(stream, onProgress) {
-        this.#iterator = stream[Symbol.asyncIterator]();
-        this.#onProgress = onProgress;
-    }
-    async #fill() {
-        if (this.#ended) {
-            throw new GitStreamingBatchResponseEndedError("git streaming batch response ended unexpectedly");
-        }
-        const next = await this.#iterator.next();
-        if (next.done) {
-            this.#ended = true;
-            throw new GitStreamingBatchResponseEndedError("git streaming batch response ended unexpectedly");
-        }
-        const chunk = Buffer.isBuffer(next.value) ? next.value : Buffer.from(next.value);
-        this.#onProgress();
-        this.#buffer = this.#buffer.length === 0 ? chunk : Buffer.concat([this.#buffer, chunk]);
-    }
-    async readLine(maxBytes) {
-        for (;;) {
-            const newline = this.#buffer.indexOf(0x0a);
-            if (newline >= 0) {
-                if (newline > maxBytes) {
-                    throw new GitStreamingBatchFramingError(`git streaming batch header exceeds ${maxBytes} bytes`);
-                }
-                const rawLine = this.#buffer.subarray(0, newline);
-                const line = rawLine.subarray(0, rawLine.length > 0 && rawLine[rawLine.length - 1] === 0x0d ? -1 : rawLine.length).toString("ascii");
-                this.#buffer = this.#buffer.subarray(newline + 1);
-                return line;
-            }
-            if (this.#buffer.length > maxBytes) {
-                throw new GitStreamingBatchFramingError(`git streaming batch header exceeds ${maxBytes} bytes without a newline`);
-            }
-            try {
-                await this.#fill();
-            }
-            catch (error) {
-                if (error instanceof GitStreamingBatchResponseEndedError) {
-                    throw new GitStreamingBatchFramingError("git streaming batch response ended before a header newline");
-                }
-                throw error;
-            }
-        }
-    }
-    async readExactly(length) {
-        while (this.#buffer.length < length)
-            await this.#fill();
-        const value = this.#buffer.subarray(0, length);
-        this.#buffer = this.#buffer.subarray(length);
-        return value;
-    }
-    async discardExactly(length) {
-        let remaining = length;
-        while (remaining > 0) {
-            if (this.#buffer.length === 0)
-                await this.#fill();
-            const consumed = Math.min(remaining, this.#buffer.length);
-            this.#buffer = this.#buffer.subarray(consumed);
-            remaining -= consumed;
-        }
-    }
-}
-/**
- * Long-lived Git batch subprocess: raw request lines, framed response records,
- * and exit/timeout/close facts only. No domain vocabulary or FlowError decisions.
- */
-export class GitStreamingBatchSession {
-    cwd;
-    #child;
-    #reader;
-    #stderr = [];
-    #timeoutMs;
-    #closed;
-    #maxHeaderBytes;
-    #signal;
-    #abortListener;
-    #timeout = null;
-    #state = { kind: "open" };
-    #timedOut = false;
-    #aborted = false;
-    #inputError = null;
-    #requestInFlight = false;
-    #requestDone = null;
-    #finishRequest = null;
-    #requestTimeoutOwner = null;
-    #closePromise = null;
-    #terminationPromise = null;
-    constructor(cwd, child, timeoutMs, maxHeaderBytes, signal) {
-        this.cwd = cwd;
-        this.#child = child;
-        this.#timeoutMs = timeoutMs;
-        this.#reader = new BufferedReader(this.#child.stdout, () => {
-            if (this.#requestTimeoutOwner)
-                this.#armTimeout(this.#requestTimeoutOwner);
-        });
-        this.#maxHeaderBytes = maxHeaderBytes;
-        this.#signal = signal;
-        this.#child.stderr.on("data", (chunk) => this.#stderr.push(chunk));
-        this.#child.stdin.on("error", (error) => {
-            this.#inputError = error;
-        });
-        this.#closed = new Promise((resolve) => {
-            this.#child.once("error", (error) => {
-                resolve({ code: null, signal: null, processError: error });
-            });
-            this.#child.once("close", (code, signal) => {
-                resolve({ code, signal });
-            });
-        });
-        this.#abortListener = () => this.abort();
-        signal?.addEventListener("abort", this.#abortListener, { once: true });
-        if (signal?.aborted)
-            this.abort();
-    }
-    #armTimeout(owner) {
-        this.#clearTimeout();
-        const handle = setTimeout(() => {
-            if (this.#timeout?.owner !== owner)
-                return;
-            this.#timeout = null;
-            this.#timedOut = true;
-            if (this.#state.kind === "open")
-                this.#state = { kind: "closing" };
-            this.#child.kill("SIGKILL");
-        }, this.#timeoutMs);
-        this.#timeout = { owner, handle };
-    }
-    #clearTimeout(owner) {
-        if (this.#timeout === null)
-            return;
-        if (owner !== undefined && this.#timeout.owner !== owner)
-            return;
-        clearTimeout(this.#timeout.handle);
-        this.#timeout = null;
-    }
-    /**
-     * Open the sole long-lived Git batch process for `cwd`.
-     * Default argv is `cat-file --batch`; callers supply compatible batch modes only.
-     */
-    static open(cwd, options) {
-        const args = options?.args ?? GIT_STREAMING_BATCH_DEFAULT_ARGS;
-        const process = openGitProcess(cwd, args, options);
-        const maxHeaderBytes = options?.maxHeaderBytes ?? GIT_STREAMING_BATCH_MAX_HEADER_BYTES;
-        return new GitStreamingBatchSession(process.cwd, process.child, process.timeoutMs, maxHeaderBytes, options?.signal);
-    }
-    /**
-     * Write one request line and read one framed response record.
-     * Honors stdin backpressure. Concurrent requests are rejected.
-     */
-    async request(expression, options) {
-        if (this.#state.kind !== "open") {
-            throw new Error("git streaming batch session is not open");
-        }
-        if (this.#requestInFlight) {
-            throw new Error("git streaming batch rejects concurrent requests");
-        }
-        const timeoutOwner = Symbol("git-streaming-batch-request");
-        this.#requestInFlight = true;
-        this.#requestTimeoutOwner = timeoutOwner;
-        this.#requestDone = new Promise((resolve) => {
-            this.#finishRequest = resolve;
-        });
-        this.#armTimeout(timeoutOwner);
-        try {
-            if (this.#inputError)
-                throw this.#inputError;
-            const line = `${expression}\n`;
-            if (!this.#child.stdin.write(line)) {
-                await new Promise((resolve, reject) => {
-                    const onDrain = () => {
-                        this.#child.stdin.off("error", onError);
-                        resolve();
-                    };
-                    const onError = (error) => {
-                        this.#child.stdin.off("drain", onDrain);
-                        reject(error);
-                    };
-                    this.#child.stdin.once("drain", onDrain);
-                    this.#child.stdin.once("error", onError);
-                });
-            }
-            let header;
-            try {
-                header = await this.#reader.readLine(this.#maxHeaderBytes);
-            }
-            catch (error) {
-                if (error instanceof GitStreamingBatchFramingError
-                    || error instanceof GitStreamingBatchResponseEndedError) {
-                    if (!this.#timedOut)
-                        this.abort();
-                }
-                throw error;
-            }
-            if (header === `${expression} missing`) {
-                return { kind: "missing", expression };
-            }
-            if (header === `${expression} ambiguous`) {
-                return { kind: "ambiguous", expression };
-            }
-            const parts = header.split(" ");
-            const [oid, type, sizeText, ...unexpected] = parts;
-            const size = Number(sizeText);
-            if (unexpected.length > 0
-                || !oid
-                || !isFullGitObjectId(oid)
-                || !type
-                || !Number.isSafeInteger(size)
-                || size < 0) {
-                this.abort();
-                throw new GitStreamingBatchFramingError(`git streaming batch returned invalid object header: ${header}`);
-            }
-            if (options?.maxContentBytes !== undefined && size > options.maxContentBytes) {
-                try {
-                    await this.#reader.discardExactly(size + 1);
-                }
-                catch (error) {
-                    this.abort();
-                    throw error;
-                }
-                // Stream stays aligned after discard; oversized is a record limit, not a framing break.
-                throw new Error(`git streaming batch object ${oid} exceeds ${options.maxContentBytes} bytes`);
-            }
-            let content;
-            let terminator;
-            try {
-                content = await this.#reader.readExactly(size);
-                terminator = await this.#reader.readExactly(1);
-            }
-            catch (error) {
-                this.abort();
-                throw error;
-            }
-            if (terminator[0] !== 0x0a) {
-                this.abort();
-                throw new GitStreamingBatchFramingError(`git streaming batch object ${oid} has an invalid frame terminator`);
-            }
-            return {
-                kind: "object",
-                record: { oid, type, size, content },
-            };
-        }
-        finally {
-            this.#clearTimeout(timeoutOwner);
-            this.#requestTimeoutOwner = null;
-            this.#requestInFlight = false;
-            const finishRequest = this.#finishRequest;
-            this.#finishRequest = null;
-            this.#requestDone = null;
-            finishRequest?.();
-        }
-    }
-    /**
-     * Idempotent kill of the child after a framing or stream-end failure.
-     * Immediately leaves `open` so no later request can write/read the destroyed child.
-     */
-    abort() {
-        if (this.#aborted)
-            return;
-        this.#aborted = true;
-        this.#clearTimeout();
-        if (this.#state.kind === "open") {
-            this.#state = { kind: "closing" };
-        }
-        this.#child.stdin.destroy();
-        this.#terminationPromise ??= terminateGitChild(this.#child, this.#closed);
-    }
-    /**
-     * End stdin, await process exit, and return structured close facts.
-     * First close may reject on process spawn error after storing the closed fact;
-     * a later close returns that stored fact. Successful and aborted close stay idempotent.
-     */
-    close() {
-        if (this.#state.kind === "closed")
-            return Promise.resolve(this.#state.fact);
-        if (this.#closePromise)
-            return this.#closePromise;
-        this.#state = { kind: "closing" };
-        // Clear the in-flight promise after settlement so a later close() returns the
-        // stored fact instead of replaying a rejected process-error promise. The
-        // returned chain is what callers await; bookkeeping must not create a second
-        // unhandled rejection.
-        this.#closePromise = this.#closeOnce().then((fact) => {
-            this.#closePromise = null;
-            return fact;
-        }, (error) => {
-            this.#closePromise = null;
-            throw error;
-        });
-        return this.#closePromise;
-    }
-    async #closeOnce() {
-        const pendingRequest = this.#requestDone;
-        if (pendingRequest)
-            await pendingRequest;
-        if (this.#terminationPromise)
-            await this.#terminationPromise;
-        const timeoutOwner = Symbol("git-streaming-batch-close");
-        if (!this.#aborted && this.#child.stdin?.writable) {
-            if (!this.#timedOut)
-                this.#armTimeout(timeoutOwner);
-            this.#child.stdin.end();
-        }
-        let exit;
-        try {
-            exit = await this.#closed;
-        }
-        finally {
-            this.#clearTimeout(timeoutOwner);
-        }
-        this.#signal?.removeEventListener("abort", this.#abortListener);
-        if (exit.processError && !this.#aborted) {
-            const fact = {
-                code: null,
-                signal: null,
-                timedOut: this.#timedOut,
-                aborted: this.#aborted,
-                stderr: Buffer.concat(this.#stderr),
-            };
-            this.#state = { kind: "closed", fact };
-            throw exit.processError;
-        }
-        const fact = {
-            code: exit.code,
-            signal: exit.signal,
-            timedOut: this.#timedOut,
-            aborted: this.#aborted,
-            stderr: Buffer.concat(this.#stderr),
-        };
-        this.#state = { kind: "closed", fact };
-        return fact;
-    }
-}
-/** Open the sole long-lived Git batch subprocess primitive. */
-export function openGitStreamingBatch(cwd, options) {
-    return GitStreamingBatchSession.open(cwd, options);
-}

package/build/git/worktree.js

@@ -1,175 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { FlowError } from "../flow-error.js";
-import { runGitProcessBytes, runGitOrThrow } from "./process.js";
-import { wrapGitError } from "./core.js";
-export const DIRTY_FILE_CATEGORY = {
-    modified: "modified",
-    added: "added",
-    deleted: "deleted",
-    renamed: "renamed",
-    conflicted: "conflicted",
-    copied: "copied",
-    untracked: "untracked",
-};
-export class GitPathEncodingError extends Error {
-    name = "GitPathEncodingError";
-    code = "GIT_PATH_ENCODING";
-    constructor() {
-        super("Git returned a path that is not valid UTF-8");
-    }
-}
-const DIRTY_WORKTREE_LIST_LIMIT = 10;
-const KEIYAKU_ARTIFACT_DIR_PREFIX = ".keiyaku/";
-const CONFLICT_STATUS_CODES = new Set(["DD", "AU", "UD", "UA", "DU", "AA", "UU"]);
-function normalizeGitPath(filePath) {
-    return filePath.replace(/^\.\/+/, "");
-}
-function dirtyCategory(index, workingDir) {
-    const code = `${index}${workingDir}`;
-    if (code === "??")
-        return DIRTY_FILE_CATEGORY.untracked;
-    if (CONFLICT_STATUS_CODES.has(code) || index === "U" || workingDir === "U")
-        return DIRTY_FILE_CATEGORY.conflicted;
-    if (index === "R" || workingDir === "R")
-        return DIRTY_FILE_CATEGORY.renamed;
-    if (index === "C" || workingDir === "C")
-        return DIRTY_FILE_CATEGORY.copied;
-    if (index === "D" || workingDir === "D")
-        return DIRTY_FILE_CATEGORY.deleted;
-    if (index === "A" || workingDir === "A")
-        return DIRTY_FILE_CATEGORY.added;
-    return DIRTY_FILE_CATEGORY.modified;
-}
-function splitNulFields(output) {
-    const fields = [];
-    let start = 0;
-    for (;;) {
-        const end = output.indexOf(0, start);
-        if (end < 0)
-            break;
-        fields.push(output.subarray(start, end));
-        start = end + 1;
-    }
-    if (start < output.length)
-        fields.push(output.subarray(start));
-    return fields;
-}
-function decodeGitPath(value) {
-    try {
-        return new TextDecoder("utf-8", { fatal: true }).decode(value);
-    }
-    catch {
-        throw new GitPathEncodingError();
-    }
-}
-/** Parse porcelain v1 -z bytes without quoting, trimming, or lossy decoding. */
-export function parsePorcelainStatusZ(output) {
-    const fields = splitNulFields(output);
-    const files = [];
-    for (let index = 0; index < fields.length; index += 1) {
-        const field = fields[index] ?? Buffer.alloc(0);
-        if (field.length === 0)
-            continue;
-        const indexCode = String.fromCharCode(field[0] ?? 0x20);
-        const workingDirCode = String.fromCharCode(field[1] ?? 0x20);
-        if (field[2] !== 0x20)
-            continue;
-        const filePath = decodeGitPath(field.subarray(3));
-        if (indexCode === "!" || workingDirCode === "!")
-            continue;
-        const renameOrCopy = indexCode === "R" || workingDirCode === "R" || indexCode === "C" || workingDirCode === "C";
-        if (renameOrCopy) {
-            decodeGitPath(fields[index + 1] ?? Buffer.alloc(0));
-            index += 1; // The second NUL field is the original path, not another status record.
-        }
-        files.push({
-            path: normalizeGitPath(filePath),
-            index: indexCode,
-            working_dir: workingDirCode,
-            category: dirtyCategory(indexCode, workingDirCode),
-        });
-    }
-    return files;
-}
-async function gitBytes(cwd, args, label) {
-    const result = await runGitProcessBytes(cwd, args);
-    if (result.error)
-        throw wrapGitError(label, result.error, cwd);
-    if (result.status !== 0) {
-        throw wrapGitError(label, Object.assign(new Error(`git exited with status ${result.status ?? "unknown"}`), {
-            stdout: result.stdout.toString("utf8"),
-            stderr: result.stderr.toString("utf8"),
-            status: result.status,
-        }), cwd);
-    }
-    return result.stdout;
-}
-async function gitOutput(cwd, args, label) {
-    try {
-        return (await runGitOrThrow(cwd, args)).stdout;
-    }
-    catch (error) {
-        throw wrapGitError(label, error, cwd);
-    }
-}
-export function renderDirtyFileStatusLine(file) {
-    const indexCode = file.index.length > 0 ? file.index : " ";
-    const worktreeCode = file.working_dir.length > 0 ? file.working_dir : " ";
-    return `${indexCode}${worktreeCode} ${file.path}`;
-}
-export async function getDirtyFiles(cwd) {
-    return parsePorcelainStatusZ(await gitBytes(cwd, ["status", "--porcelain=v1", "-z", "--untracked-files=all"], "status --porcelain"));
-}
-function normalizePathForDirtyMatch(cwd, filePath) {
-    const normalizedPath = filePath.trim();
-    if (!normalizedPath)
-        return "";
-    const repoRelativePath = path.isAbsolute(normalizedPath) ? path.relative(cwd, normalizedPath) : normalizedPath;
-    const platformNormalizedPath = path.normalize(repoRelativePath.replace(/[\\/]+/g, path.sep));
-    return platformNormalizedPath.split(path.sep).join("/").replace(/^\.\/+/, "").replace(/^\/+/, "");
-}
-/** Refuse mutations that can overwrite tracked changes in this worktree. */
-export async function assertCleanTrackedWorkingTree(cwd) {
-    const dirtyFiles = (await getDirtyFiles(cwd)).filter((file) => file.category !== DIRTY_FILE_CATEGORY.untracked);
-    if (dirtyFiles.length === 0)
-        return;
-    const shown = dirtyFiles.slice(0, DIRTY_WORKTREE_LIST_LIMIT);
-    const list = shown.map((file) => `  ${renderDirtyFileStatusLine(file)}`).join("\n");
-    const overflowCount = dirtyFiles.length - shown.length;
-    const overflowLine = overflowCount > 0 ? `\n  ... (+${overflowCount} more)` : "";
-    const hasDirtyKeiyakuArtifacts = dirtyFiles.some((file) => normalizePathForDirtyMatch(cwd, file.path).startsWith(KEIYAKU_ARTIFACT_DIR_PREFIX));
-    throw new FlowError("DIRTY_WORKTREE", `Uncommitted changes detected in working tree:\n${list}${overflowLine}\n\nBlocking changes must be committed or stashed before proceeding.`, hasDirtyKeiyakuArtifacts ? { facts: { kind: "dirty_worktree", hasKeiyakuArtifacts: true } } : undefined);
-}
-export async function getUntrackedFiles(cwd) {
-    const output = await gitBytes(cwd, ["ls-files", "--others", "--exclude-standard", "-z"], "ls-files --others --exclude-standard");
-    return Array.from(new Set(splitNulFields(output).filter((filePath) => filePath.length > 0).map(decodeGitPath).map(normalizeGitPath)));
-}
-/** Capture conflicted paths while the index still contains unmerged entries. */
-export async function getUnmergedPaths(cwd) {
-    const output = await gitBytes(cwd, ["diff", "--name-only", "--diff-filter=U", "-z"], "diff --name-only --diff-filter=U");
-    return Array.from(new Set(splitNulFields(output).filter((filePath) => filePath.length > 0).map(decodeGitPath)));
-}
-async function directoryExists(directory) {
-    try {
-        return (await fs.stat(directory)).isDirectory();
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return false;
-        throw error;
-    }
-}
-/** Git owns these paths; a lingering REBASE_HEAD alone is not active-rebase evidence. */
-export async function hasActiveRebase(cwd) {
-    const paths = await Promise.all([
-        gitOutput(cwd, ["rev-parse", "--git-path", "rebase-merge"], "rev-parse --git-path rebase state"),
-        gitOutput(cwd, ["rev-parse", "--git-path", "rebase-apply"], "rev-parse --git-path rebase state"),
-    ]);
-    const directories = paths.map((candidate) => path.resolve(cwd, candidate.trim()));
-    return (await Promise.all(directories.map(directoryExists))).some(Boolean);
-}
-export async function isPathTracked(cwd, filePath) {
-    const output = await gitOutput(cwd, ["ls-files", "-z", "--", filePath], `ls-files -- ${filePath}`);
-    return output.split("\0").some((line) => line === filePath);
-}

package/build/index.js

@@ -1,67 +0,0 @@
-#!/usr/bin/env node
-import { VERSION, GIT_HASH } from "./generated/version.js";
-import * as fs from "node:fs/promises";
-import { getConfig, initializeConfig } from "./config/env.js";
-import { ENV_KEYS } from "./config/env-keys.js";
-import { formatErrorWithCause } from "./telemetry/logger.js";
-import { runProjectionGenerationRuntime } from "./core/projection/index.js";
-import { runVerificationRuntime } from "./core/settlement/verification.js";
-import { renderCliHelp, runCliCommand } from "./cli/index.js";
-import { installCliOutputStreamErrorPolicy, writeCliOutput } from "./cli/output-stream-error-policy.js";
-import { assertSubagentCliCommandAllowed } from "./cli/subagent-guard.js";
-installCliOutputStreamErrorPolicy(process.stdout, process.stderr);
-const packageVersion = VERSION;
-function findCliCwd(args) {
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        // Tokens after the literal -- boundary are payload, never directory selectors.
-        if (arg === "--")
-            return undefined;
-        if (arg === "--cwd" || arg === "-C") {
-            const value = args[index + 1];
-            return value && value !== "--" && !value.startsWith("--") ? value : undefined;
-        }
-        if (arg?.startsWith("--cwd=")) {
-            const value = arg.slice("--cwd=".length).trim();
-            return value || undefined;
-        }
-    }
-    return undefined;
-}
-async function main() {
-    const cliArgs = process.argv.slice(2);
-    if (cliArgs[0] === "__keiyaku-wake") {
-        if (cliArgs.length !== 3 || !cliArgs[1] || !cliArgs[2])
-            throw new Error("invalid internal wake invocation");
-        // Internal only: canonicalize once at the boundary; no public command can reach here.
-        const projectionDirectory = await fs.realpath(cliArgs[1]);
-        await runProjectionGenerationRuntime(projectionDirectory, cliArgs[2]);
-        return;
-    }
-    if (cliArgs[0] === "__keiyaku-verify") {
-        if (cliArgs.length !== 3 || !cliArgs[1] || !cliArgs[2])
-            throw new Error("invalid internal verification invocation");
-        await runVerificationRuntime(cliArgs[1], cliArgs[2]);
-        return;
-    }
-    initializeConfig(process.env, findCliCwd(cliArgs) ?? process.cwd());
-    const config = getConfig();
-    assertSubagentCliCommandAllowed({
-        disableSpawn: config.subagent.disableSpawn,
-        envKey: ENV_KEYS.DISABLE_SUBAGENT_SPAWN,
-        args: cliArgs,
-    });
-    if (cliArgs.length === 1 && cliArgs[0] === "--version") {
-        await writeCliOutput(process.stdout, `${GIT_HASH ? `${packageVersion} (${GIT_HASH})` : packageVersion}\n`);
-        return;
-    }
-    if (cliArgs.length === 0 || (cliArgs.length === 1 && (cliArgs[0] === "--help" || cliArgs[0] === "-h"))) {
-        await writeCliOutput(process.stdout, `${renderCliHelp(packageVersion)}\n`);
-        return;
-    }
-    process.exitCode = await runCliCommand(cliArgs);
-}
-await main().catch(async (err) => {
-    await writeCliOutput(process.stderr, `${formatErrorWithCause("Fatal error:", err)}\n`);
-    process.exitCode = 1;
-});

package/build/keiyaku-constants.js

@@ -1,2 +0,0 @@
-export const ACTOR_IDENTITY = "Akuma";
-export const SETTINGS_PATH_SEGMENTS = [".keiyaku", "settings.json"];

package/build/keiyaku.js

@@ -1,30 +0,0 @@
-import * as path from "path";
-import { ACTOR_IDENTITY, SETTINGS_PATH_SEGMENTS } from "./keiyaku-constants.js";
-export { ACTOR_IDENTITY } from "./keiyaku-constants.js";
-export { DRAFT_ARTIFACT_NOTICE, formatArtifactDirectories, KEIYAKU_ARTIFACT_DIRS, KEIYAKU_DRAFT_DIR, RESPONSE_ARTIFACT_NOTICE, RESPONSE_HISTORY_DIR, } from "./artifact-directories.js";
-export const KEIYAKU_FILE = path.join(".keiyaku", "KEIYAKU.md");
-export const TOOL_NAMES = {
-    bind: "bind",
-    arc: "arc",
-    renew: "renew",
-    call: "call",
-    amend: "amend",
-    close: "petition",
-    status: "status",
-    help: "help",
-};
-export const ACTOR_IDENTITY_PLURAL = `${ACTOR_IDENTITY}s`;
-export const KEIYAKU_BRANCH_PREFIX = "keiyaku/";
-export const BASE_RULES_FILE = path.join(".keiyaku", "base-rules.md");
-export const SETTINGS_FILE = path.join(...SETTINGS_PATH_SEGMENTS);
-export { SUBAGENT_PROVIDERS, isSubagentProvider, BUILTIN_AGENT_PROFILES, BUILTIN_AGENT_NAMES, } from "./agents/providers/registry.js";
-export const CODEX_MODEL_REASONING_EFFORT_CONFIG_KEY = "model_reasoning_effort";
-export const DEFAULT_AGENT_NAME = "akuma-codex";
-export const CLAUDE_PERMISSION_MODES = ["default", "acceptEdits", "bypassPermissions", "plan", "dontAsk", "auto"];
-export const CLAUDE_SETTING_SOURCES = ["project", "user", "local"];
-export const CLAUDE_DEFAULT_SETTING_SOURCES = ["project"];
-export const CLAUDE_DEFAULT_PERMISSION_MODE = "bypassPermissions";
-export const CLOSE_INTENTS = ["CLAIM", "FORFEIT"];
-export const DIFF_MAX_CHARS = 8_000;
-export const DIFF_PREVIEW_TEXT_MAX_CHARS = DIFF_MAX_CHARS;
-export const ITERATE_PRIOR_ARC_SUMMARY_COUNT = 2;

package/build/telemetry/debug-log.js

@@ -1,40 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { getConfig } from "../config/env.js";
-let writeQueue = Promise.resolve();
-function resolveLogPath() {
-    const raw = getConfig().debug.logPath;
-    if (!raw)
-        return null;
-    if (path.isAbsolute(raw))
-        return raw;
-    return path.resolve(process.cwd(), raw);
-}
-function formatLine(message, section) {
-    const timestamp = new Date().toISOString();
-    const sec = section?.trim() ? ` [${section.trim()}]` : "";
-    return `[${timestamp}] [pid:${process.pid}]${sec} ${message}\n`;
-}
-export function appendDebugLog(message, options = {}) {
-    const logPath = resolveLogPath();
-    if (!logPath)
-        return;
-    const line = formatLine(message, options.section);
-    writeQueue = writeQueue
-        .then(async () => {
-        await fs.mkdir(path.dirname(logPath), { recursive: true });
-        await fs.appendFile(logPath, line, "utf-8");
-    })
-        .catch(() => {
-        // Best-effort logging should never break runtime behavior.
-    });
-}
-export function appendDebugBlock(title, content, options = {}) {
-    const text = content.trim();
-    if (!text)
-        return;
-    appendDebugLog(`${title}\n${text}`, options);
-}
-export function shouldEmitProgressLogs() {
-    return !getConfig().debug.testSilent;
-}