@astrosheep/keiyaku 0.1.47 → 0.1.49

package/build/handlers/start.js

@@ -1,8 +1,6 @@
 import { appendDebugLog } from "../utils/debug-log.js";
 import { startKeiyaku } from "../workflow/start.js";
 import { buildKeiyakuSuccessResponse, } from "../workflow/response-builders.js";
-import { resolveTermPreset } from "../config/term-presets.js";
-import { renderPreset } from "../utils/text-utils.js";
 import { handleToolError } from "./shared.js";
 function normalizeOptionalArg(value) {
     if (value === undefined)
@@ -12,14 +10,6 @@ function normalizeOptionalArg(value) {
 export function createStartHandler() {
     return async ({ from_file, title, goal, directive, context, rules, criteria, name, cwd }, extra) => {
         const workingDir = cwd || process.cwd();
-        const preset = resolveTermPreset();
-        const nextHints = renderPreset(preset.nextHints, {
-            start: preset.tools.start.name,
-            drive: preset.tools.drive.name,
-            ask: preset.tools.ask.name,
-            close: preset.tools.close.name,
-            identity: preset.identity,
-        });
         const normalizedFromFile = normalizeOptionalArg(from_file);
         const parsedCriteria = normalizeOptionalArg(criteria);
         const parsedRules = normalizeOptionalArg(rules);
@@ -55,8 +45,6 @@ export function createStartHandler() {
             });
             return buildKeiyakuSuccessResponse(result, {
                 name,
-                cwd: workingDir,
-                nextHints,
             });
         }
         catch (err) {
@@ -64,11 +52,6 @@ export function createStartHandler() {
                 error: err,
                 cwd: workingDir,
                 logLabel: "tool start",
-                inputEcho: [
-                    ...(normalizedFromFile ? [`From file: ${normalizedFromFile}`] : []),
-                    ...(name ? [`${preset.identity}: ${name}`] : []),
-                    `Path: ${workingDir}`,
-                ],
             });
         }
     };

package/build/handlers/status.js

@@ -1,5 +1,5 @@
 import { appendDebugLog } from "../utils/debug-log.js";
-import { resolveTermPreset } from "../config/term-presets.js";
+import { resolveTermPreset } from "../config/term-presets/index.js";
 import { readKeiyakuStatus } from "../workflow/status.js";
 import { buildStatusResponse } from "../workflow/response-builders.js";
 import { handleToolError } from "./shared.js";
@@ -20,7 +20,7 @@ export function createStatusHandler() {
             return buildStatusResponse(outcome, {
                 start: preset.tools.start.name,
                 drive: preset.tools.drive.name,
-                present: preset.tools.close.name,
+                close: preset.tools.close.name,
             });
         }
         catch (err) {
@@ -28,10 +28,6 @@ export function createStatusHandler() {
                 error: err,
                 cwd: workingDir,
                 logLabel: "tool status",
-                inputEcho: [
-                    `${preset.tools.status.title}: read-only`,
-                    `Path: ${workingDir}`,
-                ],
             });
         }
     };

package/build/index.js

@@ -4,9 +4,9 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
 import { readFileSync } from "node:fs";
-import { resolveOath } from "./workflow/contract.js";
+import { resolveOath } from "./workflow/keiyaku.js";
 import { askToolSchema, startToolSchema, driveToolSchema, closeToolSchema, helpToolSchema, statusToolSchema, } from "./types/tooling.js";
-import { listTermPresets, resolveTermPreset, getAvailableNamesForPreset } from "./config/term-presets.js";
+import { listTermPresets, resolveTermPreset, getAvailableNamesForPreset } from "./config/term-presets/index.js";
 import { renderPreset } from "./utils/text-utils.js";
 import { applyArgumentDescriptions } from "./utils/schema-utils.js";
 import { assertMcpServerStartupAllowed } from "./common/startup-guard.js";

package/build/types/git-diff.js

@@ -0,0 +1 @@
+export {};

package/build/utils/ask-history.js

@@ -0,0 +1,75 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+const ASK_HISTORY_DIR = path.join(".keiyaku", "history", "ask");
+const ASK_HISTORY_SLUG_MAX_LENGTH = 24;
+const ASK_HISTORY_FALLBACK_SLUG = "response";
+function toTimestampParts(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 {
+        fileStamp: `${year}${month}${day}-${hour}${minute}${second}`,
+        iso: now.toISOString(),
+    };
+}
+function toSlug(text) {
+    const normalized = text.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-");
+    const truncated = normalized
+        .slice(0, ASK_HISTORY_SLUG_MAX_LENGTH)
+        .replace(/^-+/, "")
+        .replace(/-+$/, "");
+    return truncated || ASK_HISTORY_FALLBACK_SLUG;
+}
+function toYamlSingleQuoted(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+function buildAskHistoryMarkdown(input) {
+    const sessionId = input.sessionId?.trim() || "(none)";
+    const branch = input.branch?.trim() || "(unknown)";
+    const commit = input.commit?.trim();
+    const frontMatterLines = [
+        "---",
+        `branch: ${toYamlSingleQuoted(branch)}`,
+        ...(commit ? [`commit: ${toYamlSingleQuoted(commit)}`] : []),
+        `session_id: ${toYamlSingleQuoted(sessionId)}`,
+        `time: ${toYamlSingleQuoted(input.timestampIso)}`,
+        "---",
+        "",
+    ];
+    return [
+        ...frontMatterLines,
+        "# Ask History",
+        "",
+        "## Request",
+        input.request,
+        "",
+        "## Context",
+        input.context,
+        "",
+        "## Response",
+        input.response,
+        "",
+    ].join("\n");
+}
+export async function persistAskHistory(input) {
+    const now = input.now ?? new Date();
+    const { fileStamp, iso } = toTimestampParts(now);
+    const slug = toSlug(input.summary);
+    const historyDir = path.join(input.cwd, ASK_HISTORY_DIR);
+    const savedToPath = path.join(historyDir, `${fileStamp}_${slug}.md`);
+    const markdown = buildAskHistoryMarkdown({
+        request: input.request,
+        context: input.context,
+        response: input.summary,
+        sessionId: input.sessionId,
+        branch: input.branch,
+        commit: input.commit,
+        timestampIso: iso,
+    });
+    await fs.mkdir(historyDir, { recursive: true });
+    await fs.writeFile(savedToPath, markdown, "utf-8");
+    return path.relative(input.cwd, savedToPath);
+}

package/build/utils/draft.js

@@ -0,0 +1,22 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import { KEIYAKU_DRAFT_FILE } from "../common/constants.js";
+export async function readDraftSnapshot(cwd) {
+    const draftFilePath = path.join(cwd, KEIYAKU_DRAFT_FILE);
+    try {
+        const stat = await fs.stat(draftFilePath);
+        if (!stat.isFile())
+            return null;
+        const content = await fs.readFile(draftFilePath);
+        return {
+            path: KEIYAKU_DRAFT_FILE,
+            content,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function restoreDraftSnapshot(cwd, snapshot) {
+    await fs.writeFile(path.join(cwd, snapshot.path), snapshot.content);
+}

package/build/utils/git-diff/constants.js

@@ -0,0 +1,9 @@
+export const DIFF_EXCLUDES = [":(exclude)KEIYAKU.md", ":(exclude)KEIYAKU_TRACE.md"];
+// Diff preview limits (no env/config knobs on purpose).
+export const DIFF_PREVIEW_MAX_FILES = 12;
+export const DIFF_PREVIEW_MAX_HUNKS_PER_FILE = 4;
+export const DIFF_PREVIEW_MAX_LINES_PER_HUNK = 80;
+export const DIFF_PREVIEW_MAX_PRELUDE_LINES = 50;
+export const INCREMENTAL_DIFF_RANGE = "HEAD~1...HEAD";
+export const TARGETED_DIFF_WARNING = "Warning: no valid diff coordinates found in KEIYAKU_TRACE.md; showing stat-only diff.";
+export const NOT_SHOWN_IN_DETAIL_PREFIX = "--- not shown in detail: ";

package/build/utils/git-diff/filter.js

@@ -0,0 +1,70 @@
+import { NOT_SHOWN_IN_DETAIL_PREFIX } from "./constants.js";
+import { isDeletedDiffSection, parseDiffPathFromHeader, parseUnifiedHunks, splitDiffByFile } from "./parsers.js";
+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 capTargetedDiffText(diffText, maxChars) {
+    if (diffText.length <= maxChars)
+        return diffText;
+    const cut = diffText.slice(0, maxChars);
+    return `${cut}\n...[truncated ${diffText.length - maxChars} chars]...`;
+}
+export function filterDiffByCoordinates(rawPatch, coordinates) {
+    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, rendered);
+    }
+    const selectedSections = [...selectedSectionsByPath.values(), ...deletedSections];
+    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/utils/git-diff/incremental.js

@@ -0,0 +1,111 @@
+import { DEFAULT_INCREMENTAL_DIFF_MODE, } from "../../common/constants.js";
+import { createGit, wrapGitError } from "../git-ops.js";
+import { DIFF_EXCLUDES, INCREMENTAL_DIFF_RANGE, TARGETED_DIFF_WARNING } from "./constants.js";
+import { capTargetedDiffText, filterDiffByCoordinates } from "./filter.js";
+import { isMissingBaseRevisionError, parseDiffPathFromHeader, splitDiffByFile, totalJoinedLength, truncateBlockToLineBudget } from "./parsers.js";
+import { renderStatDiffPreviewText } from "./stat.js";
+async function readIncrementalPatch(git, cwd) {
+    try {
+        return await git.raw([
+            "diff",
+            "--no-color",
+            "--no-ext-diff",
+            "--unified=3",
+            INCREMENTAL_DIFF_RANGE,
+            "--",
+            ".",
+            ...DIFF_EXCLUDES,
+        ]);
+    }
+    catch (err) {
+        if (isMissingBaseRevisionError(err)) {
+            return null;
+        }
+        throw wrapGitError(`diff --no-color --no-ext-diff --unified=3 ${INCREMENTAL_DIFF_RANGE}`, err, cwd);
+    }
+}
+function renderIncrementalUnifiedDiff(rawPatch, maxChars) {
+    const sections = splitDiffByFile(rawPatch);
+    if (sections.length === 0)
+        return "No changes in last round.";
+    const maxLinesPerFile = 90;
+    const filePreviews = [];
+    let omittedFiles = 0;
+    for (let i = 0; i < sections.length; i += 1) {
+        const section = sections[i];
+        const fileName = parseDiffPathFromHeader(section[0] ?? "") ?? "unknown";
+        const header = `--- ${fileName} ---`;
+        const content = section.slice(0, maxLinesPerFile);
+        const isTruncated = section.length > maxLinesPerFile;
+        if (isTruncated) {
+            content.push(`... [truncated ${section.length - maxLinesPerFile} lines for this file]`);
+        }
+        const fileBlock = `${header}\n${content.join("\n")}\n`;
+        const projected = totalJoinedLength([...filePreviews, fileBlock]);
+        if (projected <= maxChars) {
+            filePreviews.push(fileBlock);
+            continue;
+        }
+        omittedFiles = sections.length - i;
+        if (filePreviews.length === 0) {
+            const notice = `... [omitted ${omittedFiles} file(s) to stay under ${maxChars} chars] ...`;
+            const partialBudget = Math.max(0, maxChars - notice.length - 1);
+            const partial = truncateBlockToLineBudget(fileBlock, partialBudget);
+            if (partial.trim().length > 0) {
+                filePreviews.push(partial);
+            }
+        }
+        break;
+    }
+    if (omittedFiles > 0) {
+        const notice = `... [omitted ${omittedFiles} file(s) to stay under ${maxChars} chars] ...`;
+        while (filePreviews.length > 0 && totalJoinedLength([...filePreviews, notice]) > maxChars) {
+            filePreviews.pop();
+        }
+        if (totalJoinedLength([...filePreviews, notice]) <= maxChars) {
+            filePreviews.push(notice);
+        }
+    }
+    return filePreviews.join("\n");
+}
+async function getIncrementalUnifiedDiff(git, cwd, maxChars) {
+    const rawPatch = await readIncrementalPatch(git, cwd);
+    if (rawPatch === null)
+        return "No incremental diff available.";
+    return renderIncrementalUnifiedDiff(rawPatch, maxChars);
+}
+async function getIncrementalStatDiff(git, cwd, maxChars) {
+    let output = "";
+    try {
+        output = await git.raw(["diff", "--numstat", INCREMENTAL_DIFF_RANGE, "--", ".", ...DIFF_EXCLUDES]);
+    }
+    catch (err) {
+        if (isMissingBaseRevisionError(err))
+            return "No incremental diff available.";
+        throw wrapGitError(`diff --numstat ${INCREMENTAL_DIFF_RANGE}`, err, cwd);
+    }
+    return renderStatDiffPreviewText(output, maxChars);
+}
+export async function getIncrementalDiff(cwd, mode = DEFAULT_INCREMENTAL_DIFF_MODE, options) {
+    const git = createGit(cwd);
+    const { coordinates, maxChars } = options;
+    const renderByMode = {
+        unified: () => getIncrementalUnifiedDiff(git, cwd, maxChars.targeted),
+        stat: () => getIncrementalStatDiff(git, cwd, maxChars.stat),
+        targeted: async () => {
+            const stat = await getIncrementalStatDiff(git, cwd, maxChars.stat);
+            if (!coordinates || coordinates.length === 0) {
+                return `${stat}\n\n${TARGETED_DIFF_WARNING}`;
+            }
+            const rawPatch = await readIncrementalPatch(git, cwd);
+            if (rawPatch === null)
+                return stat;
+            const targetedPatch = filterDiffByCoordinates(rawPatch, coordinates).trim();
+            if (!targetedPatch) {
+                return `${stat}\n\n${TARGETED_DIFF_WARNING}`;
+            }
+            return `${stat}\n\n${capTargetedDiffText(targetedPatch, maxChars.targeted)}`;
+        },
+    };
+    return renderByMode[mode]();
+}

package/build/utils/git-diff/index.js

@@ -0,0 +1,3 @@
+export { filterDiffByCoordinates } from "./filter.js";
+export { getIncrementalDiff } from "./incremental.js";
+export { getDiff, getDiffPreviewText, getDiffStats } from "./preview.js";

package/build/utils/git-diff/parsers.js

@@ -0,0 +1,160 @@
+export function parseNumStat(content) {
+    const rows = [];
+    for (const line of content.split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        const [addRaw, delRaw, ...pathParts] = line.split("\t");
+        const filePath = pathParts.join("\t").trim();
+        if (!filePath)
+            continue;
+        const binary = addRaw === "-" || delRaw === "-";
+        rows.push({
+            path: filePath,
+            additions: binary ? 0 : Number.parseInt(addRaw, 10) || 0,
+            deletions: binary ? 0 : Number.parseInt(delRaw, 10) || 0,
+            binary,
+        });
+    }
+    return rows;
+}
+export function parseNameStatus(content) {
+    const map = new Map();
+    for (const line of content.split(/\r?\n/)) {
+        if (!line.trim())
+            continue;
+        const parts = line.split("\t");
+        const statusRaw = (parts[0] ?? "").trim();
+        if (!statusRaw)
+            continue;
+        if ((statusRaw.startsWith("R") || statusRaw.startsWith("C")) && parts.length >= 3) {
+            const scoreRaw = statusRaw.slice(1);
+            const score = Number.parseInt(scoreRaw, 10);
+            const oldPath = (parts[1] ?? "").trim();
+            const path = (parts[2] ?? "").trim();
+            if (!path)
+                continue;
+            const status = statusRaw[0] === "R" ? "R" : "C";
+            map.set(path, { status, score: Number.isFinite(score) ? score : 0, oldPath, path });
+            continue;
+        }
+        const path = (parts[1] ?? "").trim();
+        if (!path)
+            continue;
+        // Git can emit single-letter statuses, possibly in combinations; we keep just the first.
+        const status = statusRaw[0];
+        map.set(path, { status, path });
+    }
+    return map;
+}
+export function splitDiffByFile(content) {
+    const sections = [];
+    let current = [];
+    for (const line of content.split(/\r?\n/)) {
+        if (line.startsWith("diff --git ")) {
+            if (current.length > 0)
+                sections.push(current);
+            current = [line];
+            continue;
+        }
+        if (current.length > 0)
+            current.push(line);
+    }
+    if (current.length > 0)
+        sections.push(current);
+    return sections;
+}
+export function parseUnifiedHunks(section) {
+    const firstHunkIndex = section.findIndex((line) => line.startsWith("@@ "));
+    if (firstHunkIndex === -1) {
+        return { prelude: [...section], hunks: [] };
+    }
+    const prelude = section.slice(0, firstHunkIndex);
+    const hunks = [];
+    let current = [];
+    for (const line of section.slice(firstHunkIndex)) {
+        if (line.startsWith("@@ ")) {
+            if (current.length > 0) {
+                const parsed = parseHunkRange(current[0] ?? "");
+                if (parsed) {
+                    hunks.push({
+                        header: current[0] ?? "",
+                        lines: current.slice(1),
+                        newStart: parsed.start,
+                        newEnd: parsed.end,
+                    });
+                }
+            }
+            current = [line];
+            continue;
+        }
+        if (current.length > 0)
+            current.push(line);
+    }
+    if (current.length > 0) {
+        const parsed = parseHunkRange(current[0] ?? "");
+        if (parsed) {
+            hunks.push({
+                header: current[0] ?? "",
+                lines: current.slice(1),
+                newStart: parsed.start,
+                newEnd: parsed.end,
+            });
+        }
+    }
+    return { prelude, hunks };
+}
+function parseHunkRange(hunkHeader) {
+    const match = hunkHeader.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
+    if (!match)
+        return null;
+    const start = Number.parseInt(match[1] ?? "", 10);
+    const countRaw = match[2];
+    const count = countRaw ? Number.parseInt(countRaw, 10) : 1;
+    if (!Number.isFinite(start) || !Number.isFinite(count))
+        return null;
+    if (count <= 0)
+        return { start, end: start - 1 };
+    return { start, end: start + count - 1 };
+}
+export function isDeletedDiffSection(section) {
+    return section.some((line) => line.startsWith("deleted file mode ") || line.startsWith("+++ /dev/null"));
+}
+export function isMissingBaseRevisionError(err) {
+    const source = (err ?? {});
+    const text = [source.message, source.stderr, source.stdErr, source.stdout, source.stdOut]
+        .filter((value) => typeof value === "string" && value.length > 0)
+        .join("\n");
+    return (text.includes("bad revision") ||
+        text.includes("unknown revision or path not in the working tree") ||
+        text.includes("ambiguous argument"));
+}
+export function parseDiffPathFromHeader(diffGitLine) {
+    // Format: diff --git a/<path> b/<path>
+    const parts = diffGitLine.split(" ");
+    const bPart = parts[3] ?? "";
+    if (!bPart.startsWith("b/"))
+        return null;
+    return bPart.slice(2);
+}
+export function totalJoinedLength(blocks) {
+    if (blocks.length === 0)
+        return 0;
+    return blocks.reduce((sum, block) => sum + block.length, 0) + (blocks.length - 1);
+}
+export function truncateBlockToLineBudget(block, maxChars) {
+    if (maxChars <= 0)
+        return "";
+    if (block.length <= maxChars)
+        return block;
+    const lines = block.split("\n");
+    const kept = [];
+    let used = 0;
+    for (const line of lines) {
+        const delta = (kept.length > 0 ? 1 : 0) + line.length;
+        if (used + delta > maxChars)
+            break;
+        kept.push(line);
+        used += delta;
+    }
+    return kept.join("\n");
+}