@astrosheep/keiyaku 0.1.77 → 0.1.78

package/build/git/diff/constants.js

@@ -4,3 +4,4 @@ export const MAX_DIFF_LINES_PER_FILE = 80;
 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: ";
+export const DIFF_TRUNCATED_MARKER = "...[truncated]";

package/build/git/diff/filter.js

@@ -1,5 +1,5 @@
 import { NOT_SHOWN_IN_DETAIL_PREFIX } from "./constants.js";
-import { isDeletedDiffSection, parseDiffPathFromHeader, parseUnifiedHunks, splitDiffByFile, truncateTextWithFooter, } from "./parsers.js";
+import { isDeletedDiffSection, parseDiffPathFromHeader, parseUnifiedHunks, splitDiffByFile, truncateDiffSectionByLineCount, } from "./parsers.js";
 function rangesOverlap(aStart, aEnd, bStart, bEnd) {
     return aStart <= bEnd && bStart <= aEnd;
 }
@@ -12,21 +12,6 @@ function buildCoordinateIndex(coordinates) {
     }
     return index;
 }
-export function capTargetedDiffText(diffText, maxChars) {
-    if (diffText.length <= maxChars)
-        return diffText;
-    return truncateTextWithFooter(diffText, maxChars, diffText.length - maxChars);
-}
-function capDiffSectionByLineCount(section, maxLinesPerFile) {
-    if (maxLinesPerFile < 1)
-        return "";
-    const lines = section.split("\n");
-    if (lines.length <= maxLinesPerFile)
-        return section;
-    const truncated = lines.slice(0, maxLinesPerFile);
-    truncated.push(`... [truncated ${lines.length - maxLinesPerFile} lines for this file]`);
-    return truncated.join("\n");
-}
 export function filterDiffByCoordinates(rawPatch, coordinates, maxLinesPerFile = Number.POSITIVE_INFINITY) {
     const sections = splitDiffByFile(rawPatch);
     if (sections.length === 0)
@@ -66,11 +51,11 @@ export function filterDiffByCoordinates(rawPatch, coordinates, maxLinesPerFile =
             ...prelude,
             ...matchingHunks.flatMap((hunk) => [hunk.header, ...hunk.lines]),
         ].join("\n");
-        selectedSectionsByPath.set(coordinate.path, capDiffSectionByLineCount(rendered, maxLinesPerFile));
+        selectedSectionsByPath.set(coordinate.path, truncateDiffSectionByLineCount(rendered, maxLinesPerFile));
     }
     const selectedSections = [
         ...selectedSectionsByPath.values(),
-        ...deletedSections.map((section) => capDiffSectionByLineCount(section, maxLinesPerFile)),
+        ...deletedSections.map((section) => truncateDiffSectionByLineCount(section, maxLinesPerFile)),
     ];
     if (selectedSections.length === 0)
         return "";

package/build/git/diff/parsers.js

@@ -1,58 +1,17 @@
-const SIMPLE_NAME_STATUS_VALUES = ["A", "M", "D", "T", "U", "X", "B"];
-const SIMPLE_NAME_STATUS_SET = new Set(SIMPLE_NAME_STATUS_VALUES);
-function isSimpleNameStatus(status) {
-    return SIMPLE_NAME_STATUS_SET.has(status);
-}
-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] ?? "";
-        if (!isSimpleNameStatus(status))
-            continue;
-        map.set(path, { status, path });
-    }
-    return map;
-}
+import { Buffer } from "node:buffer";
+import { DIFF_TRUNCATED_MARKER } from "./constants.js";
+const DIFF_GIT_HEADER_PREFIX = "diff --git ";
+const GIT_QUOTED_PATH_ESCAPES = {
+    '"': 34,
+    "\\": 92,
+    a: 7,
+    b: 8,
+    f: 12,
+    n: 10,
+    r: 13,
+    t: 9,
+    v: 11,
+};
 export function splitDiffByFile(content) {
     const sections = [];
     let current = [];
@@ -135,10 +94,83 @@ export function isMissingBaseRevisionError(err) {
         text.includes("unknown revision or path not in the working tree") ||
         text.includes("ambiguous argument"));
 }
+function unescapeQuotedDiffPath(value) {
+    const bytes = [];
+    for (let index = 0; index < value.length; index += 1) {
+        const char = value[index];
+        if (char !== "\\") {
+            bytes.push(...Buffer.from(char ?? "", "utf8"));
+            continue;
+        }
+        const escaped = value[index + 1];
+        if (escaped === undefined) {
+            bytes.push(92);
+            continue;
+        }
+        if (escaped >= "0" && escaped <= "7") {
+            let octal = escaped;
+            let cursor = index + 2;
+            while (cursor < value.length && octal.length < 3) {
+                const digit = value[cursor];
+                if (digit === undefined || digit < "0" || digit > "7")
+                    break;
+                octal += digit;
+                cursor += 1;
+            }
+            bytes.push(Number.parseInt(octal, 8));
+            index = cursor - 1;
+            continue;
+        }
+        const decoded = GIT_QUOTED_PATH_ESCAPES[escaped];
+        if (decoded !== undefined) {
+            bytes.push(decoded);
+            index += 1;
+            continue;
+        }
+        bytes.push(...Buffer.from(escaped, "utf8"));
+        index += 1;
+    }
+    return Buffer.from(bytes).toString("utf8");
+}
+function readDiffHeaderToken(line, startIndex) {
+    let index = startIndex;
+    while (index < line.length && line[index] === " ") {
+        index += 1;
+    }
+    if (index >= line.length)
+        return null;
+    if (line[index] !== '"') {
+        let endIndex = index;
+        while (endIndex < line.length && line[endIndex] !== " ") {
+            endIndex += 1;
+        }
+        return {
+            value: line.slice(index, endIndex),
+            nextIndex: endIndex,
+        };
+    }
+    let endIndex = index + 1;
+    let escaped = false;
+    while (endIndex < line.length) {
+        const char = line[endIndex];
+        if (!escaped && char === '"') {
+            return {
+                value: unescapeQuotedDiffPath(line.slice(index + 1, endIndex)),
+                nextIndex: endIndex + 1,
+            };
+        }
+        escaped = !escaped && char === "\\";
+        endIndex += 1;
+    }
+    return null;
+}
 export function parseDiffPathFromHeader(diffGitLine) {
-    // Format: diff --git a/<path> b/<path>
-    const parts = diffGitLine.split(" ");
-    const bPart = parts[3] ?? "";
+    if (!diffGitLine.startsWith(DIFF_GIT_HEADER_PREFIX))
+        return null;
+    const aPart = readDiffHeaderToken(diffGitLine, DIFF_GIT_HEADER_PREFIX.length);
+    if (!aPart)
+        return null;
+    const bPart = readDiffHeaderToken(diffGitLine, aPart.nextIndex)?.value ?? "";
     if (!bPart.startsWith("b/"))
         return null;
     return bPart.slice(2);
@@ -158,20 +190,76 @@ export function truncateTextWithFooter(text, maxChars, omittedChars) {
     const cut = text.slice(0, maxChars - footer.length);
     return `${cut}${footer}`;
 }
-export function truncateBlockToLineBudget(block, maxChars) {
+function isChangedDiffLine(line) {
+    return (line.startsWith("+") && !line.startsWith("+++")) || (line.startsWith("-") && !line.startsWith("---"));
+}
+function trimUnsafeDiffBoundary(kept, remaining) {
+    if (kept.length === 0 || remaining.length === 0)
+        return kept;
+    const safe = [...kept];
+    while (safe.length > 0 && isChangedDiffLine(safe[safe.length - 1] ?? "") && isChangedDiffLine(remaining[0] ?? "")) {
+        safe.pop();
+    }
+    if ((safe[safe.length - 1] ?? "").startsWith("@@ ")) {
+        safe.pop();
+    }
+    return safe;
+}
+function renderTruncatedDiff(lines) {
+    if (lines.length === 0)
+        return DIFF_TRUNCATED_MARKER;
+    return `${lines.join("\n")}\n${DIFF_TRUNCATED_MARKER}`;
+}
+export function truncateDiffSectionByLineCount(section, maxLines) {
+    if (maxLines < 1)
+        return "";
+    const lines = section.split("\n");
+    if (lines.length <= maxLines)
+        return section;
+    const { prelude, hunks } = parseUnifiedHunks(lines);
+    if (hunks.length === 0 || prelude.length >= maxLines) {
+        return renderTruncatedDiff(trimUnsafeDiffBoundary(lines.slice(0, maxLines), lines.slice(maxLines)));
+    }
+    const kept = [...prelude];
+    let lineCount = prelude.length;
+    for (let index = 0; index < hunks.length; index += 1) {
+        const hunk = hunks[index];
+        const hunkLines = [hunk.header, ...hunk.lines];
+        if (lineCount + hunkLines.length <= maxLines) {
+            kept.push(...hunkLines);
+            lineCount += hunkLines.length;
+            continue;
+        }
+        kept.push(...hunkLines);
+        lineCount += hunkLines.length;
+        break;
+    }
+    if (lineCount >= lines.length)
+        return section;
+    return renderTruncatedDiff(kept);
+}
+export function truncateDiffBlockToCharBudget(block, maxChars) {
     if (maxChars <= 0)
         return "";
     if (block.length <= maxChars)
         return block;
+    if (DIFF_TRUNCATED_MARKER.length >= maxChars) {
+        return DIFF_TRUNCATED_MARKER.slice(0, maxChars);
+    }
     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)
+        const reservedMarker = 1 + DIFF_TRUNCATED_MARKER.length;
+        if (used + delta + reservedMarker > maxChars)
             break;
         kept.push(line);
         used += delta;
     }
-    return kept.join("\n");
+    const safe = trimUnsafeDiffBoundary(kept, lines.slice(kept.length));
+    if (safe.length === 0) {
+        return DIFF_TRUNCATED_MARKER.slice(0, maxChars);
+    }
+    return renderTruncatedDiff(safe);
 }

package/build/git/diff/preview.js

@@ -1,6 +1,5 @@
 import { createGit, wrapGitError } from "../core.js";
 import { DIFF_EXCLUDES } from "./constants.js";
-import { parseNumStat } from "./parsers.js";
 export async function getDiffStats(cwd, baseBranch) {
     const git = createGit(cwd);
     let rawNumStat;
@@ -10,7 +9,22 @@ export async function getDiffStats(cwd, baseBranch) {
     catch (err) {
         throw wrapGitError(`diff --numstat ${baseBranch}...HEAD`, err, cwd);
     }
-    const rows = parseNumStat(rawNumStat);
+    const rows = rawNumStat
+        .split(/\r?\n/)
+        .flatMap((line) => {
+        if (!line.trim())
+            return [];
+        const [addRaw, delRaw, ...pathParts] = line.split("\t");
+        const filePath = pathParts.join("\t").trim();
+        if (!filePath)
+            return [];
+        const binary = addRaw === "-" || delRaw === "-";
+        return [{
+                path: filePath,
+                additions: binary ? 0 : Number.parseInt(addRaw, 10) || 0,
+                deletions: binary ? 0 : Number.parseInt(delRaw, 10) || 0,
+            }];
+    });
     return {
         filesChanged: rows.length,
         insertions: rows.reduce((sum, row) => sum + row.additions, 0),

package/build/git/diff/read.js

@@ -1,13 +1,18 @@
 import { createGit, wrapGitError } from "../core.js";
 import { DIFF_EXCLUDES } from "./constants.js";
-import { isMissingBaseRevisionError, splitDiffByFile, totalJoinedLength, truncateBlockToLineBudget, } from "./parsers.js";
-import { renderStatDiffPreviewText } from "./stat.js";
-function buildPatchCommand(range, options) {
+import { isMissingBaseRevisionError, splitDiffByFile, totalJoinedLength, truncateDiffBlockToCharBudget, truncateDiffSectionByLineCount, truncateTextWithFooter, } from "./parsers.js";
+function normalizeDiffTarget(target) {
+    return typeof target === "string" ? [target] : [...target];
+}
+function formatDiffTarget(target) {
+    return typeof target === "string" ? target : target.join(" ");
+}
+function buildPatchCommand(target, options) {
     const args = ["diff", "--no-color", "--no-ext-diff", "--unified=3"];
     if (options.algorithm === "histogram") {
         args.push("--diff-algorithm=histogram");
     }
-    args.push(range, "--", ".", ...DIFF_EXCLUDES);
+    args.push(...normalizeDiffTarget(target), "--", ".", ...DIFF_EXCLUDES);
     return args;
 }
 function renderPatchDiff(output, options) {
@@ -26,11 +31,9 @@ function renderPatchDiff(output, options) {
     let omittedFiles = 0;
     for (let i = 0; i < sections.length; i += 1) {
         const section = sections[i];
-        const content = maxLinesPerFile === undefined ? [...section] : section.slice(0, maxLinesPerFile);
-        if (maxLinesPerFile !== undefined && section.length > maxLinesPerFile) {
-            content.push(`... [truncated ${section.length - maxLinesPerFile} lines for this file]`);
-        }
-        const fileBlock = content.join("\n");
+        const fileBlock = maxLinesPerFile === undefined
+            ? section.join("\n")
+            : truncateDiffSectionByLineCount(section.join("\n"), maxLinesPerFile);
         if (maxChars === undefined) {
             renderedSections.push(fileBlock);
             continue;
@@ -44,7 +47,7 @@ function renderPatchDiff(output, options) {
         if (renderedSections.length === 0) {
             const notice = `... [omitted ${omittedFiles} file(s) to stay under ${maxChars} chars] ...`;
             const partialBudget = Math.max(0, maxChars - totalJoinedLength(["", notice]));
-            const partial = truncateBlockToLineBudget(fileBlock, partialBudget);
+            const partial = truncateDiffBlockToCharBudget(fileBlock, partialBudget);
             if (partial.trim()) {
                 renderedSections.push(partial);
             }
@@ -62,20 +65,29 @@ function renderPatchDiff(output, options) {
     }
     return renderedSections.join("\n\n").trim() || "No diff.";
 }
-export async function readDiff(cwd, range, format, options = {}) {
+export async function readDiff(cwd, target, format, options = {}) {
     const git = createGit(cwd);
+    const formattedTarget = formatDiffTarget(target);
     try {
         if (format === "stat") {
             const statVariant = options.statVariant ?? "summary";
             const args = statVariant === "numstat"
-                ? ["diff", "--numstat", range, "--", ".", ...DIFF_EXCLUDES]
-                : ["diff", "--stat=120,80", "--compact-summary", range, "--", ".", ...DIFF_EXCLUDES];
+                ? ["diff", "--numstat", ...normalizeDiffTarget(target), "--", ".", ...DIFF_EXCLUDES]
+                : ["diff", "--stat=120,80", "--compact-summary", ...normalizeDiffTarget(target), "--", ".", ...DIFF_EXCLUDES];
             const output = await git.raw(args);
-            return statVariant === "summary"
-                ? renderStatDiffPreviewText(output, options.maxChars ?? Number.POSITIVE_INFINITY)
-                : output.trim() || "No diff.";
+            if (statVariant !== "summary") {
+                return output.trim() || "No diff.";
+            }
+            const trimmed = output.trim();
+            if (!trimmed)
+                return "No diff.";
+            const maxChars = options.maxChars ?? Number.POSITIVE_INFINITY;
+            if (trimmed.length <= maxChars) {
+                return trimmed;
+            }
+            return truncateTextWithFooter(trimmed, maxChars, trimmed.length - maxChars);
         }
-        const output = await git.raw(buildPatchCommand(range, options));
+        const output = await git.raw(buildPatchCommand(target, options));
         return renderPatchDiff(output, options);
     }
     catch (error) {
@@ -84,9 +96,9 @@ export async function readDiff(cwd, range, format, options = {}) {
         }
         const commandLabel = format === "stat"
             ? options.statVariant === "numstat"
-                ? `diff --numstat ${range}`
-                : `diff --stat=120,80 --compact-summary ${range}`
-            : `diff --no-color --no-ext-diff --unified=3 ${range}`;
+                ? `diff --numstat ${formattedTarget}`
+                : `diff --stat=120,80 --compact-summary ${formattedTarget}`
+            : `diff --no-color --no-ext-diff --unified=3 ${formattedTarget}`;
         throw wrapGitError(commandLabel, error, cwd);
     }
 }

package/build/git/snapshot.js

@@ -1,7 +1,7 @@
 import * as fs from "fs/promises";
 import * as os from "os";
 import * as path from "path";
-import { MISSING_HEAD_PATTERNS, NOT_GIT_REPOSITORY_PATTERNS, createGit, errorContainsAnyPattern, wrapGitError } from "./core.js";
+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");
@@ -18,26 +18,8 @@ export async function createWorkspaceSnapshot(cwd) {
     try {
         return await withTempIndex(cwd, async (git) => {
             await git.raw(["add", "-A"]);
-            const tree = (await git.raw(["write-tree"])).trim();
-            if (!tree)
-                return undefined;
-            let head;
-            try {
-                head = (await git.revparse(["--verify", "HEAD"])).trim() || undefined;
-            }
-            catch (error) {
-                if (!errorContainsAnyPattern(error, MISSING_HEAD_PATTERNS)) {
-                    throw wrapGitError("rev-parse --verify HEAD", error, cwd);
-                }
-                head = undefined;
-            }
-            const args = ["commit-tree", tree];
-            if (head) {
-                args.push("-p", head);
-            }
-            args.push("-m", "keiyaku ask snapshot");
-            const sha = await git.raw(args);
-            return sha.trim() || undefined;
+            const tree = await git.raw(["write-tree"]);
+            return tree.trim() || undefined;
         });
     }
     catch (error) {
@@ -50,11 +32,10 @@ export async function createWorkspaceSnapshot(cwd) {
 export async function getChangedFilesBetweenSnapshots(cwd, beforeSha, afterSha) {
     const git = createGit(cwd);
     try {
-        const output = await git.raw(["diff", "--name-status", `${beforeSha}..${afterSha}`]);
+        const output = await git.raw(["diff", "--name-status", beforeSha, afterSha]);
         return output.trim();
     }
     catch (err) {
-        throw wrapGitError(`diff --name-status ${beforeSha}..${afterSha}`, err, cwd);
+        throw wrapGitError(`diff --name-status ${beforeSha} ${afterSha}`, err, cwd);
     }
 }
-export { withTempIndex };

package/build/git/worktree.js

@@ -6,6 +6,7 @@ export const DIRTY_FILE_CATEGORY = {
     renamed: "renamed",
     conflicted: "conflicted",
     copied: "copied",
+    untracked: "untracked",
 };
 function normalizeGitPath(filePath) {
     return filePath.trim().replace(/^\.\/+/, "");
@@ -22,6 +23,9 @@ function toDirtyStatusPathSets(status) {
     };
 }
 function deriveDirtyFileCategory(file, statusPathSets) {
+    if (statusPathSets.untracked.has(file.path)) {
+        return DIRTY_FILE_CATEGORY.untracked;
+    }
     if (statusPathSets.conflicted.has(file.path)) {
         return DIRTY_FILE_CATEGORY.conflicted;
     }
@@ -56,10 +60,7 @@ export async function getDirtyFiles(cwd) {
         throw wrapGitError("status --porcelain", err, cwd);
     }
     const statusPathSets = toDirtyStatusPathSets(status);
-    return status.files
-        .filter((file) => !(file.index === "?" && file.working_dir === "?"))
-        .filter((file) => !statusPathSets.untracked.has(file.path))
-        .map((file) => ({
+    return status.files.map((file) => ({
         path: file.path,
         index: file.index,
         working_dir: file.working_dir,

package/build/mcp/server.js

@@ -1,7 +1,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { resolveOath } from "../protocol/oath.js";
-import { amendToolSchema, askToolSchemaBase, attachAskResponsePathValidation, summonToolSchema, driveToolSchema, petitionToolSchema, helpToolSchema, statusToolSchema, } from "../tools/schema.js";
-import { getAvailableNamesForPreset, listTermPresets, resolveTermPreset } from "../config/term-presets/resolver.js";
+import { amendToolSchema, askToolSchema, summonToolSchema, driveToolSchema, petitionToolSchema, helpToolSchema, statusToolSchema, } from "../tools/schema.js";
+import { getAvailableNamesForPreset, resolveTermPreset } from "../config/term-presets/resolver.js";
 import { renderPreset } from "../config/render-template.js";
 import { applyArgumentDescriptions } from "../config/apply-argument-descriptions.js";
 import { createAmendHandler } from "../tools/amend/index.js";
@@ -13,9 +13,6 @@ import { createHelpHandler } from "../tools/help.js";
 import { createStatusHandler } from "../tools/status/index.js";
 function registerTools(server, packageVersion) {
     const preset = resolveTermPreset();
-    const presetIdentities = listTermPresets()
-        .map((item) => `${item.id}=${item.identity}`)
-        .join(", ");
     const availableNames = getAvailableNamesForPreset(preset).join(", ");
     const currentOath = resolveOath();
     const renderedPreset = renderPreset(preset, {
@@ -25,73 +22,68 @@ function registerTools(server, packageVersion) {
         amend: preset.tools.amend.name,
         close: preset.tools.close.name,
         identity: preset.identity,
-        preset_identities: presetIdentities,
         available_names: availableNames,
         oath_text: `'${currentOath}'`,
     });
-    const startPreset = renderedPreset.tools.start;
-    const drivePreset = renderedPreset.tools.drive;
-    const askPreset = renderedPreset.tools.ask;
-    const amendPreset = renderedPreset.tools.amend;
-    const closePreset = renderedPreset.tools.close;
-    const helpPreset = renderedPreset.tools.help;
-    const statusPreset = renderedPreset.tools.status;
-    const dynamicCloseSchema = applyArgumentDescriptions(petitionToolSchema, {
-        ...closePreset.args,
-    });
-    const dynamicStartSchema = applyArgumentDescriptions(summonToolSchema, {
-        ...startPreset.args,
-    });
-    const dynamicDriveSchema = applyArgumentDescriptions(driveToolSchema, {
-        ...drivePreset.args,
-    });
-    const dynamicAskSchema = attachAskResponsePathValidation(applyArgumentDescriptions(askToolSchemaBase, {
-        ...askPreset.args,
-    }));
-    const dynamicAmendSchema = applyArgumentDescriptions(amendToolSchema, {
-        ...amendPreset.args,
-    });
-    const dynamicHelpSchema = applyArgumentDescriptions(helpToolSchema, {
-        ...helpPreset.args,
-    });
-    const dynamicStatusSchema = applyArgumentDescriptions(statusToolSchema, {
-        ...statusPreset.args,
-    });
-    server.registerTool(startPreset.name, {
-        title: startPreset.title,
-        description: startPreset.description,
-        inputSchema: dynamicStartSchema,
-    }, createSummonHandler());
-    server.registerTool(drivePreset.name, {
-        title: drivePreset.title,
-        description: drivePreset.description,
-        inputSchema: dynamicDriveSchema,
-    }, createDriveHandler());
-    server.registerTool(askPreset.name, {
-        title: askPreset.title,
-        description: askPreset.description,
-        inputSchema: dynamicAskSchema,
-    }, createAskHandler());
-    server.registerTool(amendPreset.name, {
-        title: amendPreset.title,
-        description: amendPreset.description,
-        inputSchema: dynamicAmendSchema,
-    }, createAmendHandler());
-    server.registerTool(closePreset.name, {
-        title: closePreset.title,
-        description: closePreset.description,
-        inputSchema: dynamicCloseSchema,
-    }, createPetitionHandler());
-    server.registerTool(helpPreset.name, {
-        title: helpPreset.title,
-        description: helpPreset.description,
-        inputSchema: dynamicHelpSchema,
-    }, createHelpHandler(renderedPreset, packageVersion));
-    server.registerTool(statusPreset.name, {
-        title: statusPreset.title,
-        description: statusPreset.description,
-        inputSchema: dynamicStatusSchema,
-    }, createStatusHandler());
+    const tools = [
+        {
+            key: "start",
+            schema: applyArgumentDescriptions(summonToolSchema, {
+                ...renderedPreset.tools.start.args,
+            }),
+            handler: createSummonHandler(),
+        },
+        {
+            key: "drive",
+            schema: applyArgumentDescriptions(driveToolSchema, {
+                ...renderedPreset.tools.drive.args,
+            }),
+            handler: createDriveHandler(),
+        },
+        {
+            key: "ask",
+            schema: applyArgumentDescriptions(askToolSchema, {
+                ...renderedPreset.tools.ask.args,
+            }),
+            handler: createAskHandler(),
+        },
+        {
+            key: "amend",
+            schema: applyArgumentDescriptions(amendToolSchema, {
+                ...renderedPreset.tools.amend.args,
+            }),
+            handler: createAmendHandler(),
+        },
+        {
+            key: "close",
+            schema: applyArgumentDescriptions(petitionToolSchema, {
+                ...renderedPreset.tools.close.args,
+            }),
+            handler: createPetitionHandler(),
+        },
+        {
+            key: "help",
+            schema: applyArgumentDescriptions(helpToolSchema, {
+                ...renderedPreset.tools.help.args,
+            }),
+            handler: createHelpHandler(renderedPreset, packageVersion),
+        },
+        {
+            key: "status",
+            schema: applyArgumentDescriptions(statusToolSchema, {
+                ...renderedPreset.tools.status.args,
+            }),
+            handler: createStatusHandler(),
+        },
+    ];
+    for (const tool of tools) {
+        const toolPreset = renderedPreset.tools[tool.key];
+        server.registerTool(toolPreset.name, {
+            title: toolPreset.title,
+            description: toolPreset.description,
+            inputSchema: tool.schema,
+        }, tool.handler);
+    }
 }
 export function createServer(packageVersion) {
     const server = new McpServer({