@astrosheep/keiyaku 0.1.87 → 1.0.1

package/build/git/diff/filter.js

@@ -1,67 +0,0 @@
-import { isDeletedDiffSection, parseDiffPathFromHeader, parseUnifiedHunks, splitDiffByFile, truncateDiffSectionByLineCount, } from "./parsers.js";
-const NOT_SHOWN_IN_DETAIL_PREFIX = "--- not shown in detail: ";
-function rangesOverlap(aStart, aEnd, bStart, bEnd) {
-    return aStart <= bEnd && bStart <= aEnd;
-}
-function buildCoordinateIndex(coordinates) {
-    const index = new Map();
-    for (const coordinate of coordinates) {
-        const existing = index.get(coordinate.path) ?? [];
-        existing.push(coordinate);
-        index.set(coordinate.path, existing);
-    }
-    return index;
-}
-export function filterDiffByCoordinates(rawPatch, coordinates, maxLinesPerFile = Number.POSITIVE_INFINITY) {
-    const sections = splitDiffByFile(rawPatch);
-    if (sections.length === 0)
-        return "";
-    const byPath = buildCoordinateIndex(coordinates);
-    const selectedSectionsByPath = new Map();
-    const deletedSections = [];
-    const nonDeletedPathsInPatch = [];
-    const sectionByPath = new Map();
-    for (const section of sections) {
-        const path = parseDiffPathFromHeader(section[0] ?? "");
-        if (!path)
-            continue;
-        if (isDeletedDiffSection(section)) {
-            deletedSections.push(section.join("\n"));
-            continue;
-        }
-        if (!sectionByPath.has(path)) {
-            nonDeletedPathsInPatch.push(path);
-            sectionByPath.set(path, section);
-        }
-    }
-    for (const coordinate of coordinates) {
-        const section = sectionByPath.get(coordinate.path);
-        if (!section || selectedSectionsByPath.has(coordinate.path))
-            continue;
-        const fileCoordinates = byPath.get(coordinate.path);
-        if (!fileCoordinates || fileCoordinates.length === 0)
-            continue;
-        const { prelude, hunks } = parseUnifiedHunks(section);
-        if (hunks.length === 0)
-            continue;
-        const matchingHunks = hunks.filter((hunk) => fileCoordinates.some((coord) => rangesOverlap(hunk.newStart, hunk.newEnd, coord.start, coord.end)));
-        if (matchingHunks.length === 0)
-            continue;
-        const rendered = [
-            ...prelude,
-            ...matchingHunks.flatMap((hunk) => [hunk.header, ...hunk.lines]),
-        ].join("\n");
-        selectedSectionsByPath.set(coordinate.path, truncateDiffSectionByLineCount(rendered, maxLinesPerFile));
-    }
-    const selectedSections = [
-        ...selectedSectionsByPath.values(),
-        ...deletedSections.map((section) => truncateDiffSectionByLineCount(section, maxLinesPerFile)),
-    ];
-    if (selectedSections.length === 0)
-        return "";
-    const filteredOutPaths = nonDeletedPathsInPatch.filter((path) => !selectedSectionsByPath.has(path));
-    if (filteredOutPaths.length > 0) {
-        selectedSections.push(`${NOT_SHOWN_IN_DETAIL_PREFIX}${filteredOutPaths.join(", ")}`);
-    }
-    return selectedSections.join("\n");
-}

package/build/git/keiyaku-state.js

@@ -1,58 +0,0 @@
-import { KEIYAKU_BRANCH_PREFIX } from "../keiyaku.js";
-import { MISSING_GIT_CONFIG_PATTERNS, createGit, errorContainsAnyPattern, wrapGitError, } from "./core.js";
-import { getCurrentBranch } from "./branches.js";
-export async function getActiveKeiyakuGitState(cwd) {
-    const branch = await getCurrentBranch(cwd);
-    if (!branch.startsWith(KEIYAKU_BRANCH_PREFIX))
-        return null;
-    const baseBranch = await getKeiyakuBase(cwd, branch);
-    if (!baseBranch)
-        return null;
-    return { branch, baseBranch };
-}
-function branchBaseKey(branchName) {
-    return `branch.${branchName}.keiyakuBase`;
-}
-export async function setKeiyakuBase(cwd, branchName, baseBranch) {
-    const git = createGit(cwd);
-    try {
-        await git.raw(["config", branchBaseKey(branchName), baseBranch]);
-    }
-    catch (err) {
-        throw wrapGitError(`config ${branchBaseKey(branchName)} ${baseBranch}`, err, cwd);
-    }
-}
-export async function getKeiyakuBase(cwd, branchName) {
-    const git = createGit(cwd);
-    try {
-        const value = await git.raw(["config", "--default", "", "--get", branchBaseKey(branchName)]);
-        return value.trim() || null;
-    }
-    catch (error) {
-        throw wrapGitError(`config --default '' --get ${branchBaseKey(branchName)}`, error, cwd);
-    }
-}
-export async function clearKeiyakuBase(cwd, branchName) {
-    const git = createGit(cwd);
-    const key = branchBaseKey(branchName);
-    let currentValue = "";
-    try {
-        currentValue = (await git.raw(["config", "--default", "", "--get", key])).trim();
-    }
-    catch (error) {
-        throw wrapGitError(`config --default '' --get ${key}`, error, cwd);
-    }
-    if (!currentValue) {
-        return;
-    }
-    try {
-        await git.raw(["config", "--unset", key]);
-    }
-    catch (error) {
-        if (errorContainsAnyPattern(error, MISSING_GIT_CONFIG_PATTERNS)) {
-            return;
-        }
-        throw wrapGitError(`config --unset ${key}`, error, cwd);
-    }
-}
-export { branchBaseKey };

package/build/git/snapshot.js

@@ -1,41 +0,0 @@
-import * as fs from "fs/promises";
-import * as os from "os";
-import * as path from "path";
-import { NOT_GIT_REPOSITORY_PATTERNS, createGit, errorContainsAnyPattern, wrapGitError } from "./core.js";
-async function withTempIndex(cwd, run) {
-    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "keiyaku-git-index-"));
-    const tempIndexPath = path.join(tempDir, "index");
-    const git = createGit(cwd);
-    git.env("GIT_INDEX_FILE", tempIndexPath);
-    try {
-        return await run(git);
-    }
-    finally {
-        await fs.rm(tempDir, { recursive: true, force: true });
-    }
-}
-export async function createWorkspaceSnapshot(cwd) {
-    try {
-        return await withTempIndex(cwd, async (git) => {
-            await git.raw(["add", "-A"]);
-            const tree = await git.raw(["write-tree"]);
-            return tree.trim() || undefined;
-        });
-    }
-    catch (error) {
-        if (errorContainsAnyPattern(error, NOT_GIT_REPOSITORY_PATTERNS)) {
-            return undefined;
-        }
-        throw wrapGitError("create workspace snapshot", error, cwd);
-    }
-}
-export async function getChangedFilesBetweenSnapshots(cwd, beforeSha, afterSha) {
-    const git = createGit(cwd);
-    try {
-        const output = await git.raw(["diff", "--name-status", beforeSha, afterSha]);
-        return output.trim();
-    }
-    catch (err) {
-        throw wrapGitError(`diff --name-status ${beforeSha} ${afterSha}`, err, cwd);
-    }
-}

package/build/git/stash.js

@@ -1,62 +0,0 @@
-import { createGit, wrapGitError } from "./core.js";
-function parseStashRefs(raw) {
-    return raw
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter((line) => line.length > 0);
-}
-async function listStashRefs(cwd) {
-    const git = createGit(cwd);
-    try {
-        const output = await git.raw(["stash", "list", "--format=%gd"]);
-        return parseStashRefs(output);
-    }
-    catch (err) {
-        throw wrapGitError("stash list --format=%gd", err, cwd);
-    }
-}
-export async function createSafetyStash(cwd, message) {
-    const before = await listStashRefs(cwd);
-    const git = createGit(cwd);
-    try {
-        await git.raw(["stash", "push", "--include-untracked", "--message", message]);
-    }
-    catch (err) {
-        throw wrapGitError(`stash push --include-untracked --message ${message}`, err, cwd);
-    }
-    const after = await listStashRefs(cwd);
-    if (after.length === before.length) {
-        return null;
-    }
-    return after[0] ?? null;
-}
-export async function applyStash(cwd, stashRef) {
-    const git = createGit(cwd);
-    try {
-        await git.raw(["stash", "apply", stashRef]);
-    }
-    catch (err) {
-        throw wrapGitError(`stash apply ${stashRef}`, err, cwd);
-    }
-}
-export async function dropStash(cwd, stashRef) {
-    const git = createGit(cwd);
-    try {
-        await git.raw(["stash", "drop", stashRef]);
-    }
-    catch (err) {
-        throw wrapGitError(`stash drop ${stashRef}`, err, cwd);
-    }
-}
-export async function discardAllWorkingTreeChanges(cwd) {
-    await resetHardHead(cwd);
-}
-export async function resetHardHead(cwd) {
-    const git = createGit(cwd);
-    try {
-        await git.raw(["reset", "--hard", "HEAD"]);
-    }
-    catch (err) {
-        throw wrapGitError("reset --hard HEAD", err, cwd);
-    }
-}

package/build/protocol/bind-draft.js

@@ -1,195 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { isErrnoException } from "../errno.js";
-import { buildBindDraftRecoveryHints, buildBindDraftSaveFailureHint, } from "../config/architect-hints.js";
-import { FlowError, isFlowError, requireText, wrapFlowError } from "../flow-error.js";
-import { writeDraftArtifact, listDraftArtifacts } from "./draft-artifacts.js";
-import { logInfo } from "../telemetry/logger.js";
-import { parseAndValidateKeiyakuDraft } from "./keiyaku-draft.js";
-const INTERNAL_BIND_DIRTY_ALLOWLIST = [];
-const REQUIRED_BIND_FIELDS = ["title", "goal", "context", "criteria"];
-function normalizeOptionalText(value) {
-    if (value === undefined)
-        return undefined;
-    const normalized = value.trim();
-    return normalized.length > 0 ? normalized : undefined;
-}
-function resolveFromDraftPath(cwd, fromDraft) {
-    return path.isAbsolute(fromDraft) ? fromDraft : path.join(cwd, fromDraft);
-}
-export function resolveGitRelativePath(cwd, filePath) {
-    const relativePath = path.relative(cwd, filePath);
-    if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
-        return null;
-    }
-    return relativePath.split(path.sep).join("/");
-}
-function normalizeOptionalMarkdownText(name, value) {
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== "string") {
-        throw new FlowError("INVALID_KEIYAKU_DRAFT", `invalid keiyaku draft: field '${name}' must be a markdown string`);
-    }
-    const normalized = value.trim();
-    return normalized.length > 0 ? normalized : undefined;
-}
-function assertRequiredBindFields(values) {
-    for (const field of REQUIRED_BIND_FIELDS) {
-        if (!values[field]) {
-            throw new FlowError("INVALID_KEIYAKU_DRAFT", `invalid keiyaku draft: missing required field '${field}'`);
-        }
-    }
-}
-export async function resolveBindInput(cwd, input) {
-    const fromDraft = normalizeOptionalText(input.from_draft);
-    const dirtyAllowlist = [...INTERNAL_BIND_DIRTY_ALLOWLIST];
-    const provided = {
-        title: normalizeOptionalText(input.title),
-        goal: normalizeOptionalText(input.goal),
-        context: normalizeOptionalText(input.context),
-        criteria: normalizeOptionalMarkdownText("criteria", input.criteria),
-        rules: normalizeOptionalMarkdownText("rules", input.rules),
-    };
-    if (!fromDraft) {
-        assertRequiredBindFields({
-            title: provided.title,
-            goal: provided.goal,
-            context: provided.context,
-            criteria: provided.criteria,
-        });
-        return {
-            title: requireText("title", provided.title),
-            goal: requireText("goal", provided.goal),
-            context: requireText("context", provided.context),
-            criteria: requireText("criteria", provided.criteria),
-            rules: provided.rules ?? "",
-            fromDraft: undefined,
-            fromDraftPath: undefined,
-            dirtyAllowlist,
-        };
-    }
-    const draftPath = resolveFromDraftPath(cwd, fromDraft);
-    let content;
-    try {
-        content = await fs.readFile(draftPath, "utf-8");
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT") {
-            throw new FlowError("FROM_DRAFT_NOT_FOUND", `from_draft path does not exist: ${fromDraft}`);
-        }
-        throw error;
-    }
-    const draft = parseAndValidateKeiyakuDraft(content);
-    const title = provided.title ?? draft.title;
-    const goal = provided.goal ?? draft.goal;
-    const context = provided.context ?? draft.context;
-    const criteria = provided.criteria ?? draft.criteria;
-    const rules = provided.rules ?? draft.rules ?? "";
-    assertRequiredBindFields({
-        title,
-        goal,
-        context,
-        criteria,
-    });
-    return {
-        title: requireText("title", title),
-        goal: requireText("goal", goal),
-        context: requireText("context", context),
-        criteria: requireText("criteria", criteria),
-        rules,
-        fromDraft,
-        fromDraftPath: draftPath,
-        dirtyAllowlist,
-    };
-}
-export async function readRollbackDraftSnapshot(cwd, candidatePath) {
-    const relativePath = resolveGitRelativePath(cwd, candidatePath);
-    if (!relativePath)
-        return null;
-    const absolutePath = path.join(cwd, relativePath);
-    try {
-        const stat = await fs.stat(absolutePath);
-        if (!stat.isFile())
-            return null;
-        const content = await fs.readFile(absolutePath);
-        return { relativePath, content };
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT") {
-            return null;
-        }
-        throw error;
-    }
-}
-export async function captureRollbackDraftSnapshots(cwd, fromDraftPath) {
-    const canonicalDraftPaths = await listDraftArtifacts(cwd);
-    const candidatePaths = canonicalDraftPaths.map((relativePath) => path.join(cwd, relativePath));
-    if (fromDraftPath)
-        candidatePaths.push(fromDraftPath);
-    const snapshots = await Promise.all(candidatePaths.map((candidatePath) => readRollbackDraftSnapshot(cwd, candidatePath)));
-    const uniqueSnapshots = new Map();
-    for (const snapshot of snapshots) {
-        if (!snapshot)
-            continue;
-        uniqueSnapshots.set(snapshot.relativePath, snapshot);
-    }
-    return [...uniqueSnapshots.values()];
-}
-export async function restoreRollbackDraftSnapshots(cwd, snapshots) {
-    for (const snapshot of snapshots) {
-        const absolutePath = path.join(cwd, snapshot.relativePath);
-        await fs.mkdir(path.dirname(absolutePath), { recursive: true });
-        await fs.writeFile(absolutePath, snapshot.content);
-    }
-}
-export async function handleBindFailure(cwd, error, keiyakuContent, title, fromDraft) {
-    let savedDraft = false;
-    let retryHints = [];
-    let draftSaveFailed;
-    if (keiyakuContent && !fromDraft) {
-        try {
-            const draftPath = await writeDraftArtifact({
-                cwd,
-                title,
-                content: keiyakuContent,
-            });
-            retryHints = buildBindDraftRecoveryHints(draftPath);
-            logInfo(`[keiyaku] Bind failed. Draft saved to ${draftPath}.`, { cwd, section: "script", progressOnly: true });
-            savedDraft = true;
-        }
-        catch (draftSaveError) {
-            const message = draftSaveError instanceof Error ? draftSaveError.message : String(draftSaveError);
-            draftSaveFailed = message;
-            logInfo(`[keiyaku] Failed to save draft file: ${message}`, { cwd, section: "script", progressOnly: true });
-        }
-    }
-    if (error instanceof Error && error.name === "AbortError") {
-        throw wrapFlowError("bind keiyaku", error);
-    }
-    if (savedDraft) {
-        if (isFlowError(error)) {
-            throw wrapFlowError("bind keiyaku", new FlowError(error.code, error.message, {
-                cause: error,
-                hints: retryHints,
-            }));
-        }
-        if (error instanceof Error) {
-            throw wrapFlowError("bind keiyaku", new FlowError("INTERNAL_STATE", error.message, { cause: error, hints: retryHints }));
-        }
-        throw wrapFlowError("bind keiyaku", new FlowError("INTERNAL_STATE", String(error), { hints: retryHints }));
-    }
-    if (draftSaveFailed) {
-        const draftSaveHint = buildBindDraftSaveFailureHint(draftSaveFailed);
-        if (isFlowError(error)) {
-            throw wrapFlowError("bind keiyaku", new FlowError(error.code, error.message, {
-                cause: error,
-                hints: [draftSaveHint],
-            }));
-        }
-        if (error instanceof Error) {
-            throw wrapFlowError("bind keiyaku", new FlowError("INTERNAL_STATE", error.message, { cause: error, hints: [draftSaveHint] }));
-        }
-        throw wrapFlowError("bind keiyaku", new FlowError("INTERNAL_STATE", String(error), { hints: [draftSaveHint] }));
-    }
-    throw wrapFlowError("bind keiyaku", error);
-}

package/build/protocol/draft-artifacts.js

@@ -1,99 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { DRAFT_ARTIFACT_NOTICE, KEIYAKU_DRAFT_DIR } from "../keiyaku.js";
-import { isErrnoException } from "../errno.js";
-const DRAFT_SLUG_FALLBACK = "keiyaku-draft";
-function normalizeDraftRelativePath(relativePath) {
-    return relativePath.split(path.sep).join("/");
-}
-function formatDraftTimestamp(now) {
-    const year = String(now.getFullYear());
-    const month = String(now.getMonth() + 1).padStart(2, "0");
-    const day = String(now.getDate()).padStart(2, "0");
-    const hour = String(now.getHours()).padStart(2, "0");
-    const minute = String(now.getMinutes()).padStart(2, "0");
-    const second = String(now.getSeconds()).padStart(2, "0");
-    return `${year}${month}${day}-${hour}${minute}${second}`;
-}
-function toDraftSlug(title) {
-    const normalized = title
-        .trim()
-        .toLowerCase()
-        .replace(/[^\p{Script=Han}a-z0-9]+/gu, "-")
-        .replace(/-+/g, "-")
-        .replace(/^-+/, "")
-        .replace(/-+$/, "");
-    return normalized || DRAFT_SLUG_FALLBACK;
-}
-export function isDraftArtifactPath(filePath) {
-    const normalized = normalizeDraftRelativePath(filePath).replace(/^\.\/+/, "");
-    const draftPrefix = `${normalizeDraftRelativePath(KEIYAKU_DRAFT_DIR)}/`;
-    return normalized === normalizeDraftRelativePath(KEIYAKU_DRAFT_DIR) || normalized.startsWith(draftPrefix);
-}
-export function buildDraftArtifactRelativePath(title, now = new Date()) {
-    const filename = `${formatDraftTimestamp(now)}_${toDraftSlug(title)}.md`;
-    return normalizeDraftRelativePath(path.join(KEIYAKU_DRAFT_DIR, filename));
-}
-function buildDraftArtifactMarkdown(content, now) {
-    return [
-        "---",
-        "generated_by: keiyaku",
-        "type: draft",
-        `time: '${now.toISOString()}'`,
-        `notice: '${DRAFT_ARTIFACT_NOTICE}'`,
-        "---",
-        "",
-        content,
-    ].join("\n");
-}
-export async function writeDraftArtifact(input) {
-    const now = input.now ?? new Date();
-    const relativePath = buildDraftArtifactRelativePath(input.title, now);
-    const absolutePath = path.join(input.cwd, relativePath);
-    await fs.mkdir(path.dirname(absolutePath), { recursive: true });
-    await fs.writeFile(absolutePath, buildDraftArtifactMarkdown(input.content, now), "utf-8");
-    return relativePath;
-}
-export async function listDraftArtifacts(cwd) {
-    const draftDirPath = path.join(cwd, KEIYAKU_DRAFT_DIR);
-    try {
-        const entries = await fs.readdir(draftDirPath, { withFileTypes: true });
-        return entries
-            .filter((entry) => entry.isFile())
-            .map((entry) => normalizeDraftRelativePath(path.join(KEIYAKU_DRAFT_DIR, entry.name)))
-            .sort((a, b) => b.localeCompare(a));
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT") {
-            return [];
-        }
-        throw error;
-    }
-}
-export async function readLatestDraftArtifact(cwd) {
-    const [latestPath] = await listDraftArtifacts(cwd);
-    if (!latestPath)
-        return null;
-    const content = await fs.readFile(path.join(cwd, latestPath), "utf-8");
-    return { path: latestPath, content };
-}
-export async function readDraftSnapshot(cwd) {
-    const draftPaths = await listDraftArtifacts(cwd);
-    if (draftPaths.length === 0)
-        return null;
-    const files = await Promise.all(draftPaths.map(async (draftPath) => ({
-        path: draftPath,
-        content: await fs.readFile(path.join(cwd, draftPath)),
-    })));
-    return {
-        path: draftPaths[0],
-        files,
-    };
-}
-export async function restoreDraftSnapshot(cwd, snapshot) {
-    for (const file of snapshot.files) {
-        const absolutePath = path.join(cwd, file.path);
-        await fs.mkdir(path.dirname(absolutePath), { recursive: true });
-        await fs.writeFile(absolutePath, file.content);
-    }
-}

package/build/protocol/file-guards.js

@@ -1,24 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { KEIYAKU_FILE } from "../keiyaku.js";
-import { isErrnoException } from "../errno.js";
-import { FlowError } from "../flow-error.js";
-async function isMissingFile(filePath) {
-    try {
-        await fs.access(filePath);
-        return false;
-    }
-    catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT") {
-            return true;
-        }
-        throw error;
-    }
-}
-export async function assertKeiyakuProtocolFiles(cwd) {
-    const keiyakuPath = path.join(cwd, KEIYAKU_FILE);
-    const hasKeiyaku = !(await isMissingFile(keiyakuPath));
-    if (!hasKeiyaku) {
-        throw new FlowError("MISSING_PROTOCOL_FILES", `missing protocol file for current keiyaku (${KEIYAKU_FILE})`);
-    }
-}