@astrosheep/keiyaku 0.1.86 → 1.0.0

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})`);
-    }
-}

package/build/protocol/keiyaku-draft.js

@@ -1,168 +0,0 @@
-import { FlowError } from "../flow-error.js";
-import { KeiyakuParseError, parseToAST, renderSectionContent, } from "./markdown/index.js";
-import { computeHeadingDelta } from "./markdown/normalization.js";
-const KNOWN_DRAFT_SECTIONS = new Set([
-    "goal",
-    "context",
-    "rules",
-    "criteria",
-    "acceptance criteria",
-]);
-function normalizeSectionTitle(title) {
-    return title.trim().toLowerCase().replace(/\s+/g, " ");
-}
-function parseFenceLine(trimmedLine) {
-    if (!trimmedLine.startsWith("```"))
-        return null;
-    let idx = 0;
-    while (idx < trimmedLine.length && trimmedLine[idx] === "`")
-        idx += 1;
-    if (idx < 3)
-        return null;
-    return idx;
-}
-function normalizeDraftHeadings(content) {
-    const lines = content.split(/\r?\n/);
-    if (lines.length > 0) {
-        lines[0] = lines[0].replace(/^\uFEFF/, "");
-    }
-    // Keep structural title/known section headings stable, and shift payload headings together.
-    const MIN_HEADING_LEVEL = 3;
-    let sawTitleH1 = false;
-    let fence = null;
-    let shallowestNonStructural = null;
-    for (const line of lines) {
-        let leadingSpaces = 0;
-        while (leadingSpaces < line.length && line[leadingSpaces] === " ")
-            leadingSpaces += 1;
-        const trimmed = leadingSpaces <= 3 ? line.trimStart() : line;
-        if (leadingSpaces <= 3) {
-            const fenceLen = parseFenceLine(trimmed);
-            if (fenceLen !== null) {
-                if (!fence)
-                    fence = { length: fenceLen };
-                else if (fenceLen >= fence.length)
-                    fence = null;
-                continue;
-            }
-        }
-        if (fence)
-            continue;
-        if (leadingSpaces > 3)
-            continue;
-        const headerMatch = trimmed.match(/^(#{1,6})[ \t]+(.+?)\s*$/);
-        if (!headerMatch)
-            continue;
-        const level = (headerMatch[1] ?? "").length;
-        const text = (headerMatch[2] ?? "").trim();
-        if (level === 1 && !sawTitleH1) {
-            sawTitleH1 = true;
-            continue;
-        }
-        if (level === 2) {
-            // Keep ALL H2 section headers structural in from_draft drafts. Unknown headers
-            // should remain visible to validation instead of being silently demoted.
-            continue;
-        }
-        shallowestNonStructural = shallowestNonStructural === null ? level : Math.min(shallowestNonStructural, level);
-    }
-    const delta = computeHeadingDelta(shallowestNonStructural, MIN_HEADING_LEVEL);
-    if (delta === 0) {
-        return lines.join("\n");
-    }
-    const out = [];
-    sawTitleH1 = false;
-    fence = null;
-    for (const line of lines) {
-        let leadingSpaces = 0;
-        while (leadingSpaces < line.length && line[leadingSpaces] === " ")
-            leadingSpaces += 1;
-        const trimmed = leadingSpaces <= 3 ? line.trimStart() : line;
-        const prefix = line.slice(0, leadingSpaces);
-        if (leadingSpaces <= 3) {
-            const fenceLen = parseFenceLine(trimmed);
-            if (fenceLen !== null) {
-                if (!fence)
-                    fence = { length: fenceLen };
-                else if (fenceLen >= fence.length)
-                    fence = null;
-                out.push(line);
-                continue;
-            }
-        }
-        if (fence) {
-            out.push(line);
-            continue;
-        }
-        if (leadingSpaces <= 3) {
-            const headerMatch = trimmed.match(/^(#{1,6})[ \t]+(.+?)\s*$/);
-            if (headerMatch) {
-                const hashes = headerMatch[1] ?? "";
-                const text = (headerMatch[2] ?? "").trim();
-                const level = hashes.length;
-                if (level === 1) {
-                    if (!sawTitleH1) {
-                        sawTitleH1 = true;
-                        out.push(line);
-                        continue;
-                    }
-                    out.push(`${prefix}${"#".repeat(Math.min(6, level + delta))} ${text}`);
-                    continue;
-                }
-                if (level === 2) {
-                    out.push(line);
-                    continue;
-                }
-                out.push(`${prefix}${"#".repeat(Math.min(6, level + delta))} ${text}`);
-                continue;
-            }
-        }
-        out.push(line);
-    }
-    return out.join("\n");
-}
-export function parseAndValidateKeiyakuDraft(content) {
-    try {
-        const normalized = normalizeDraftHeadings(content);
-        const ast = parseToAST(normalized);
-        const sections = new Map();
-        let title;
-        for (const node of ast.children) {
-            if (node.type !== "section")
-                continue;
-            if (node.level === 1 && !title) {
-                title = node.title.trim() || undefined;
-                continue;
-            }
-            if (node.level !== 2)
-                continue;
-            const normalizedSection = normalizeSectionTitle(node.title);
-            if (sections.has(normalizedSection)) {
-                throw new FlowError("INVALID_KEIYAKU_DRAFT", `invalid keiyaku draft: duplicate section header '${normalizedSection}'`);
-            }
-            sections.set(normalizedSection, renderSectionContent(node).trim());
-        }
-        const unknownSections = [...sections.keys()].filter((section) => !KNOWN_DRAFT_SECTIONS.has(section));
-        if (unknownSections.length > 0) {
-            const allowedSections = [...KNOWN_DRAFT_SECTIONS].map((section) => `'${section}'`).join(", ");
-            throw new FlowError("INVALID_KEIYAKU_DRAFT", `invalid keiyaku draft: unknown section header(s): ${unknownSections.map((section) => `'${section}'`).join(", ")}. Valid section header(s): ${allowedSections}. Fix the header or delete the draft file and retry.`);
-        }
-        const goal = sections.get("goal")?.trim();
-        const context = sections.get("context")?.trim();
-        const rules = sections.get("rules")?.trim();
-        const criteria = sections.get("acceptance criteria")?.trim() ?? sections.get("criteria")?.trim();
-        return {
-            title: title?.trim() || undefined,
-            goal: goal || undefined,
-            context: context || undefined,
-            rules: rules || undefined,
-            criteria: criteria || undefined,
-        };
-    }
-    catch (error) {
-        if (error instanceof KeiyakuParseError) {
-            throw new FlowError("INVALID_KEIYAKU_DRAFT", `invalid keiyaku draft: ${error.message}`, { cause: error });
-        }
-        throw error;
-    }
-}