genshin-mods 4.3.3 → 4.5.0

package/src/services/sins/SinStatusTextMap.ts

@@ -0,0 +1,10 @@
+import type { SinStatus } from "../../../types";
+
+import { SinStatusKind } from "../../models/SinStatusKind";
+
+// Why the band and the pane say so instead of fresh scores, for the statuses that have a reason to say
+export const SinStatusTextMap: Partial<Record<SinStatus, string>> = {
+  [SinStatusKind.Failed]: "Last prompt not scored",
+  [SinStatusKind.NodeTooOld]: "Needs Node 22.13 or later on 22, or 23.4 or later on 23",
+  [SinStatusKind.NoKey]: "Needs a TypeSafe key",
+};

package/src/services/sins/appendSinEvidence.ts

@@ -0,0 +1,18 @@
+import type { SinsResult } from "../../models/SinsResult";
+import type { SinStatusKind } from "../../models/SinStatusKind";
+
+import { SIN_NAMES } from "../../models/SinName";
+import { SIN_HISTORY_LENGTH, SIN_TOP_LEVEL } from "./constants";
+
+// Each sin's evidence gains this prompt's score as a share of the top level, clamped to [0, 1], and the oldest values fall
+// Away past the history's length
+export const appendSinEvidence = (
+  history: Record<string, number[]>,
+  answers: Extract<SinsResult, { result: SinStatusKind.Answered }>["answers"],
+): Record<string, number[]> =>
+  Object.fromEntries(
+    SIN_NAMES.map((name) => {
+      const evidence = Math.min(1, Math.max(0, (answers[name]?.score ?? 0) / SIN_TOP_LEVEL));
+      return [name, [...(history[name] ?? []), evidence].slice(-SIN_HISTORY_LENGTH)];
+    }),
+  );

package/src/services/sins/constants.ts

@@ -0,0 +1,33 @@
+// The five levels every question grades on, from none to extreme, so the sins are comparable with one another
+export const SIN_CRITERIA = [
+  "Absent: the prompt shows none of it",
+  "Slight: a trace of it in passing",
+  "Moderate: it shapes part of the prompt",
+  "Strong: it shapes most of the prompt",
+  "Extreme: it is the whole prompt",
+] as const;
+
+// The top level the score reads, so a score divides by it to lie between none and extreme
+export const SIN_TOP_LEVEL: number = SIN_CRITERIA.length - 1;
+
+// The half-life in prompts: a sin's score moves about halfway toward a new pattern within this many prompts
+export const SIN_HALF_LIFE_PROMPTS = 30;
+
+// Applied to the old counts on each prompt, so each count halves every half-life
+export const SIN_DISCOUNT: number = 2 ** (-1 / SIN_HALF_LIFE_PROMPTS);
+
+// One pseudo-count of each outcome, so a sin with no evidence reads as an even half
+export const SIN_PRIOR = 1;
+
+// The evidence kept per sin: past this the discount has taken the rest, under a tenth of a percent
+export const SIN_HISTORY_LENGTH = 300;
+
+// The bar's width in cells, the solid run to the score and the tinted run to the score plus its spread
+export const SIN_BAR_WIDTH = 24;
+
+export const SINS_PANE_ID = "sins";
+
+// The node script's whole run, its one request included; a run past this is killed and reads as failed
+export const SINS_TIMEOUT_MS = 60_000;
+
+export const SINS_API_URL = "https://api.typesafe.ai/v1/systemone";

package/src/services/sins/getBarCells.ts

@@ -0,0 +1,8 @@
+import type { SinFigures } from "../../models/SinFigures";
+
+// The solid run reaches the score, and the tinted run the score plus its spread, both in cells of the bar's width
+export const getBarCells = ({ score, spread }: SinFigures, width: number): { solid: number; tinted: number } => {
+  const solid = Math.round(score * width);
+  const reach = Math.round(Math.min(1, score + spread) * width);
+  return { solid, tinted: Math.max(0, reach - solid) };
+};

package/src/services/sins/getPosteriorTrail.ts

@@ -0,0 +1,21 @@
+import type { SinPosterior } from "../../models/SinPosterior";
+
+import { SIN_DISCOUNT, SIN_PRIOR } from "./constants";
+
+// Each evidence value is replayed in order, the counts discounted before it is added, so the trail is the posterior
+// After each prompt and its last entry is the posterior now
+export const getPosteriorTrail = (evidences: number[]): SinPosterior[] => {
+  let posterior: SinPosterior = { alpha: SIN_PRIOR, beta: SIN_PRIOR };
+  return evidences.map((evidence) => {
+    posterior = {
+      alpha: SIN_DISCOUNT * posterior.alpha + evidence,
+      beta: SIN_DISCOUNT * posterior.beta + (1 - evidence),
+    };
+    return posterior;
+  });
+};
+
+// The posterior now is the trail's last entry, and a sin with no evidence reads as the prior: an even half with the spread
+// Of one count of each outcome
+export const getPosterior = (trail: SinPosterior[]): SinPosterior =>
+  trail.at(-1) ?? { alpha: SIN_PRIOR, beta: SIN_PRIOR };

package/src/services/sins/getScoreAndSpread.ts

@@ -0,0 +1,8 @@
+import type { SinFigures } from "../../models/SinFigures";
+import type { SinPosterior } from "../../models/SinPosterior";
+
+// The score is the posterior mean and the spread its standard deviation, from the Beta's own variance
+export const getScoreAndSpread = ({ alpha, beta }: SinPosterior): SinFigures => {
+  const total = alpha + beta;
+  return { score: alpha / total, spread: Math.sqrt((alpha * beta) / (total * total * (total + 1))) };
+};

package/src/services/sins/getSinQuestions.ts

@@ -0,0 +1,28 @@
+import { SIN_NAMES, SinName } from "../../models/SinName";
+import { SIN_CRITERIA } from "./constants";
+
+// The question each sin asks Jev about a prompt, held beside the one call that asks them all
+const SinQuestionMap = {
+  [SinName.Envy]:
+    'How far does the prompt measure against another tool, person or project, as in "the other tool", "like theirs" or "why doesn\'t ours do what X does"?',
+  [SinName.Gluttony]: "How heavy is the prompt, as in a large pasted share of text or a whole file or log pasted in?",
+  [SinName.Greed]:
+    'How far does the prompt ask for more than one request holds, as in "and also", "while you\'re at it", "everything" or several tasks at once?',
+  [SinName.Lust]:
+    'How far does the prompt crave the new over the finished, as in "rewrite", "from scratch", "redesign" or "a new approach"?',
+  [SinName.Pride]:
+    'How far does the prompt assert certainty and wave off checks, as in "obviously", "definitely", "no need to test" or "trust me"?',
+  [SinName.Sloth]:
+    'How far is effort handed off without a steer, as in "idk", "whatever", "you decide", "figure it out" or a one-word prompt?',
+  [SinName.Wrath]:
+    'How heated is the prompt\'s register, as in runs of punctuation, words in capitals, "again", "still broken" or "why won\'t"?',
+} as const satisfies Record<SinName, string>;
+
+// The seven `score` questions one call answers, keyed by sin name, each graded on the same five levels
+export const getSinQuestions = (): Record<
+  string,
+  { criteria: typeof SIN_CRITERIA; instructions: string; type: "score" }
+> =>
+  Object.fromEntries(
+    SIN_NAMES.map((name) => [name, { criteria: SIN_CRITERIA, instructions: SinQuestionMap[name], type: "score" }]),
+  );

package/src/services/sins/getSinScores.ts

@@ -0,0 +1,17 @@
+import type { SinScore } from "../../models/SinScore";
+
+import { SIN_NAMES } from "../../models/SinName";
+import { getPosterior, getPosteriorTrail } from "./getPosteriorTrail";
+import { getScoreAndSpread } from "./getScoreAndSpread";
+import { getTrend } from "./getTrend";
+
+// The sins the person can read, in the pane's order: one with no evidence is left out rather than shown as a zero
+export const getSinScores = (history: Record<string, number[]>): SinScore[] =>
+  SIN_NAMES.flatMap((name) => {
+    const evidences = history[name] ?? [];
+    if (evidences.length === 0) return [];
+
+    const trail = getPosteriorTrail(evidences);
+    const figures = getScoreAndSpread(getPosterior(trail));
+    return [{ name, ...figures, trend: getTrend(trail) }];
+  });

package/src/services/sins/getTrend.ts

@@ -0,0 +1,13 @@
+import type { SinPosterior } from "../../models/SinPosterior";
+
+import { SIN_HALF_LIFE_PROMPTS } from "./constants";
+
+const TREND_GLYPHS = "▁▂▃▄▅▆▇█";
+
+// The score after each of the last half-life's prompts, from the trail the score reads, so it is the score's own curve
+export const getTrend = (trail: SinPosterior[]): number[] =>
+  trail.slice(-SIN_HALF_LIFE_PROMPTS).map(({ alpha, beta }) => alpha / (alpha + beta));
+
+// One glyph per point, its height the point's share of the tallest glyph
+export const getTrendGlyphs = (trend: number[]): string =>
+  trend.map((score) => TREND_GLYPHS.charAt(Math.round(score * (TREND_GLYPHS.length - 1)))).join("");

package/src/services/sins/parseSinsResult.ts

@@ -0,0 +1,5 @@
+import type { SinsResult } from "../../models/SinsResult";
+
+// The node script writes one JSON result when it exits cleanly, so a run that exited otherwise never reaches this
+// oxlint-disable-next-line no-restricted-properties -- packages/genshin-mods/package.json has no @esposter/shared dependency, so jsonDateParse is not importable here, and SinsResult (src/models/SinsResult.ts) holds no Date a revival would produce
+export const parseSinsResult = (stdout: string): SinsResult => JSON.parse(stdout) as SinsResult;

package/src/services/sins/pickTypeSafeKey.ts

@@ -0,0 +1,4 @@
+// The key sins scores with: the plugin's own option when it is set, else the variable. A blank option is no key, so the
+// Variable answers, and `||` is what makes it so, since `??` would keep a blank option over a variable that holds one
+export const pickTypeSafeKey = (typeSafeKey: string, variableKey: string | undefined): string =>
+  typeSafeKey || variableKey || "";

package/src/services/sins/readIsLightTheme.ts

@@ -0,0 +1,8 @@
+import type { EngineInterface } from "claude-code";
+
+// The engine's theme row names a light theme with "light" in it, and any other theme reads as dark
+// oxlint-disable-next-line func-style -- A declaration, not an arrow: the hooks module's bundle follows an imported helper that takes `$` only into a function declaration
+export async function readIsLightTheme($: EngineInterface): Promise<boolean> {
+  const theme = (await $.config.list()).find(({ key }) => key === "theme");
+  return String(theme?.value ?? "").includes("light");
+}

package/src/services/sins/readSinStatus.ts

@@ -0,0 +1,20 @@
+import type { EngineInterface } from "claude-code";
+
+import { atom, read } from "claude-code";
+
+import type { SinStatus } from "../../../types";
+
+import { SinStatusKind } from "../../models/SinStatusKind";
+import { InitialState } from "../InitialState";
+import { readTypeSafeKey } from "./readTypeSafeKey";
+
+const sinStatusAtom = atom({ key: "sinStatus", plugin: "genshin-mods" } as const, InitialState.sinStatus);
+
+// The status as the band and the pane draw it: a key removed since the last prompt is said so at each draw, before the next
+// Prompt would say it, and the stored status stands otherwise
+// oxlint-disable-next-line func-style -- A declaration, not an arrow: the hooks module's bundle follows an imported helper that takes `$` into a function declaration
+export async function readSinStatus($: EngineInterface, typeSafeKey: string): Promise<SinStatus> {
+  if (!(await readTypeSafeKey($, typeSafeKey))) return SinStatusKind.NoKey;
+
+  return read($, sinStatusAtom);
+}

package/src/services/sins/readTypeSafeKey.ts

@@ -0,0 +1,10 @@
+import type { EngineInterface } from "claude-code";
+
+import { pickTypeSafeKey } from "./pickTypeSafeKey";
+
+// The key sins scores with: the plugin's option, else the TYPESAFE_API_KEY variable, the two places Genshin-persona reads
+// Its key from, so one key set the same way serves both plugins
+// oxlint-disable-next-line func-style -- A declaration, not an arrow: the hooks module's bundle follows an imported helper that takes `$` into a function declaration
+export async function readTypeSafeKey($: EngineInterface, typeSafeKey: string): Promise<string> {
+  return pickTypeSafeKey(typeSafeKey, await $.env.get("TYPESAFE_API_KEY"));
+}

package/src/services/sins/registerSins.ts

@@ -0,0 +1,56 @@
+import type { On } from "claude-code";
+
+import { atom, read } from "claude-code";
+
+import { InitialState } from "../InitialState";
+import { SIN_BAR_WIDTH, SINS_PANE_ID } from "./constants";
+import { getBarCells } from "./getBarCells";
+import { getSinScores } from "./getSinScores";
+import { getTrendGlyphs } from "./getTrend";
+import { readIsLightTheme } from "./readIsLightTheme";
+import { readSinStatus } from "./readSinStatus";
+import { SinColorMap } from "./SinColorMap";
+import { SinStatusTextMap } from "./SinStatusTextMap";
+
+const enabledModsAtom = atom({ key: "enabledMods", plugin: "genshin-mods" } as const, InitialState.enabledMods);
+const sinHistoryAtom = atom({ key: "sinHistory", plugin: "genshin-mods" } as const, InitialState.sinHistory);
+
+// The seven sins in full: one bar per measured sin in the same order every time, its spread as the tinted tail, and its
+// Last thirty prompts as a trend. It is drawn from the state alone, so a reload redraws it as it was, and it says so
+// Rather than drawing stale bars once the switch is off
+export const registerSins = (on: On, typeSafeKey: string): void => {
+  on("ui.render", { component: "Pane", requestId: SINS_PANE_ID }, async ($, e) => {
+    const { Box, Text } = $.ui.resolve(e);
+    if (!(await read($, enabledModsAtom)).sins)
+      return Box({
+        children: [Text({ children: "Sins is off: turn it on with /sins on.", dimColor: true })],
+        flexDirection: "column",
+      });
+
+    const scores = getSinScores(await read($, sinHistoryAtom));
+    const isLight = await readIsLightTheme($);
+    const statusText = SinStatusTextMap[await readSinStatus($, typeSafeKey)];
+    return Box({
+      children: [
+        Text({ bold: true, children: "Seven sins" }),
+        ...(scores.length === 0 ? [Text({ children: "No prompt scored yet.", dimColor: true })] : []),
+        ...scores.map(({ name, score, spread, trend }) => {
+          const color = SinColorMap[name][isLight ? "light" : "dark"];
+          const { solid, tinted } = getBarCells({ score, spread }, SIN_BAR_WIDTH);
+          const bar = "█".repeat(solid) + "▒".repeat(tinted) + " ".repeat(SIN_BAR_WIDTH - solid - tinted);
+          return Box({
+            children: [
+              Text({ children: name.padEnd(9), color }),
+              Text({ children: bar, color }),
+              Text({ children: `${Math.round(score * 100)}% ±${Math.round(spread * 100)}`.padEnd(12) }),
+              Text({ children: getTrendGlyphs(trend), color }),
+            ],
+            flexDirection: "row",
+          });
+        }),
+        ...(statusText ? [Text({ children: statusText, dimColor: true })] : []),
+      ],
+      flexDirection: "column",
+    });
+  });
+};

package/src/services/sins/sinsScript.ts

@@ -0,0 +1,47 @@
+import { SinStatusKind } from "../../models/SinStatusKind";
+
+// The plugin's node script, run as `node --input-type=module -e` with its request on stdin: the one network call and the
+// Evidence log run here, since the hooks module has no Node. It is a string because a plugin reaches none of its own
+// Files from inside the module, and it writes exactly one JSON result, so a run that exits otherwise reads as failed
+// oxlint-disable-next-line typescript/no-inferrable-types -- isolatedDeclarations asks for the type of an exported template that interpolates, and this rule would refuse that annotation
+export const SINS_SCRIPT: string = `
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+
+let input = "";
+for await (const chunk of process.stdin) input += chunk;
+const { apiUrl, key, questions, session, state, storePath } = JSON.parse(input);
+const finish = (result) => process.stdout.write(JSON.stringify(result));
+const sqlite = process.getBuiltinModule?.("node:sqlite");
+
+if (!key) finish({ result: "${SinStatusKind.NoKey}" });
+else if (!sqlite) finish({ result: "${SinStatusKind.NodeTooOld}" });
+else {
+  const response = await fetch(apiUrl, {
+    body: JSON.stringify({ model: "jev-latest", questions, state }),
+    headers: { Authorization: "Bearer " + key, "Content-Type": "application/json" },
+    method: "POST",
+  });
+  const answers = response.ok ? (await response.json()).answers || {} : {};
+  const names = Object.keys(questions);
+  const isAnswered = names.every(
+    (name) => typeof answers[name]?.score === "number" && typeof answers[name]?.confidence === "number",
+  );
+  if (!isAnswered) finish({ reason: response.ok ? "unanswered" : "HTTP " + response.status, result: "${SinStatusKind.Failed}" });
+  else {
+    mkdirSync(dirname(storePath), { recursive: true });
+    const database = new sqlite.DatabaseSync(storePath);
+    try {
+      database.exec("PRAGMA busy_timeout = 5000");
+      database.exec(
+        "CREATE TABLE IF NOT EXISTS evidence (id INTEGER PRIMARY KEY, session INTEGER NOT NULL, answers TEXT NOT NULL, recorded_at INTEGER NOT NULL)",
+      );
+      const picked = Object.fromEntries(names.map((name) => [name, { confidence: answers[name].confidence, score: answers[name].score }]));
+      database.prepare("INSERT INTO evidence (session, answers, recorded_at) VALUES (?, ?, ?)").run(session, JSON.stringify(picked), Date.now());
+      finish({ answers: picked, result: "${SinStatusKind.Answered}" });
+    } finally {
+      database.close();
+    }
+  }
+}
+`;

package/src/services/ward/getAddRefusal.ts

@@ -0,0 +1,14 @@
+import { isWholeCheckout } from "./isWholeCheckout";
+import { splitArguments } from "./splitArguments";
+
+const ADD_ALL_FLAGS: ReadonlySet<string> = new Set(["--all", "--update", "-A", "-u"]);
+
+// `add .`, `add -A` and `add -N` over every path reach a peer's work, while a named path does not
+export const getAddRefusal = (args: string[]): string | undefined => {
+  const { flags, operands } = splitArguments(args);
+  if (isWholeCheckout(operands)) return "git add .";
+  const allFlag = flags.find((flag) => ADD_ALL_FLAGS.has(flag));
+  if (allFlag !== undefined && operands.length === 0) return `git add ${allFlag}`;
+  const isIntentToAdd = flags.some((flag) => flag === "-N" || flag === "--intent-to-add");
+  return isIntentToAdd && operands.length === 0 ? "git add -N" : undefined;
+};

package/src/services/ward/getCheckoutPeer.ts

@@ -1,9 +1,7 @@
 import type { WardRecord } from "../../../types";
 
 import { getCollidingRecord } from "./getCollidingRecord";
-
-// Windows paths compare as one spelling: forward slashes, lowercase, since the file system ignores case
-const getComparablePath = (path: string) => path.replaceAll("\\", "/").toLowerCase();
+import { getComparablePath } from "./getComparablePath";
 
 // The edited path of another session's record inside this checkout, undefined when no other session in the window
 // Shares it, so a checkout alone with its session is never refused

package/src/services/ward/getCheckoutRefusal.ts

@@ -0,0 +1,6 @@
+import { isWholeCheckout } from "./isWholeCheckout";
+import { splitArguments } from "./splitArguments";
+
+// `checkout .` and `checkout -- .` overwrite every path's working tree copy, a peer's edits included
+export const getCheckoutRefusal = (args: string[]): string | undefined =>
+  isWholeCheckout(splitArguments(args).operands) ? "git checkout ." : undefined;

package/src/services/ward/getCleanRefusal.ts

@@ -0,0 +1,8 @@
+import { splitArguments } from "./splitArguments";
+
+// A clean deletes every untracked file, a peer's new ones included; a dry run lists them and is allowed
+export const getCleanRefusal = (args: string[]): string | undefined => {
+  const { flags } = splitArguments(args);
+  const isDryRun = flags.some((flag) => flag === "--dry-run" || (!flag.startsWith("--") && flag.includes("n")));
+  return isDryRun ? undefined : "git clean";
+};

package/src/services/ward/getComparablePath.ts

@@ -0,0 +1,2 @@
+// Windows paths compare as one spelling: forward slashes, lowercase, since the file system ignores case
+export const getComparablePath = (path: string) => path.replaceAll("\\", "/").toLowerCase();

package/src/services/ward/getGitRefusal.ts

@@ -0,0 +1,32 @@
+import type { CommandRefusal } from "../../models/CommandRefusal";
+
+import { joinDirectory } from "../shell/joinDirectory";
+import { getAddRefusal } from "./getAddRefusal";
+import { getCheckoutRefusal } from "./getCheckoutRefusal";
+import { getCleanRefusal } from "./getCleanRefusal";
+import { getResetRefusal } from "./getResetRefusal";
+import { getRestoreRefusal } from "./getRestoreRefusal";
+import { getStashRefusal } from "./getStashRefusal";
+import { getSubcommand } from "./getSubcommand";
+
+const GIT_NAMES: ReadonlySet<string> = new Set(["git", "git.exe"]);
+
+const WHOLE_INDEX_REFUSALS: ReadonlyMap<string, (args: string[]) => string | undefined> = new Map([
+  ["add", getAddRefusal],
+  ["checkout", getCheckoutRefusal],
+  ["clean", getCleanRefusal],
+  ["reset", getResetRefusal],
+  ["restore", getRestoreRefusal],
+  ["stash", getStashRefusal],
+]);
+
+// The form refused and the folder git runs in, from the session's ("" for the session's own): the folder a `cd` before
+// It moved to, then each of its `-C` folders
+export const getGitRefusal: CommandRefusal<{ directory: string; form: string }> = (name, args, directory) => {
+  if (!GIT_NAMES.has(name)) return undefined;
+  const subcommand = getSubcommand(args);
+  const form = WHOLE_INDEX_REFUSALS.get(subcommand.name)?.(subcommand.arguments);
+  return form === undefined
+    ? undefined
+    : { directory: subcommand.directories.reduce((base, next) => joinDirectory(base, next), directory), form };
+};

package/src/services/ward/getResetRefusal.ts

@@ -0,0 +1,19 @@
+import { isWholeCheckout } from "./isWholeCheckout";
+import { splitArguments } from "./splitArguments";
+
+// The reset modes that touch the working tree or the index beyond HEAD, so a reset with one of them is not a commit move
+const RESET_INDEX_MODES: ReadonlySet<string> = new Set(["--hard", "--keep", "--merge", "--mixed"]);
+
+// A reset that names a path is path-scoped: after `--`, or as a second operand with none, since git reads the first
+// As a commit or a path and every one after it as a path. The checkout's own pathspec names no commit, so it is the
+// Whole checkout in either place. A lone operand may be a commit, so it is refused, and a reset that moves HEAD alone
+// With `--soft` leaves the index as it is; every other reset rewrites the index to HEAD or the working tree, a peer's
+// Staged entries included
+export const getResetRefusal = (args: string[]): string | undefined => {
+  const { after, flags, hasSeparator, operands } = splitArguments(args);
+  if (isWholeCheckout(hasSeparator ? after : operands)) return "git reset -- .";
+  const paths = hasSeparator ? after : operands.slice(1);
+  if (paths.length > 0) return undefined;
+  const isSoftOnly = flags.includes("--soft") && !flags.some((flag) => RESET_INDEX_MODES.has(flag));
+  return isSoftOnly ? undefined : "git reset";
+};

package/src/services/ward/getRestoreRefusal.ts

@@ -0,0 +1,10 @@
+import { isWholeCheckout } from "./isWholeCheckout";
+import { splitArguments } from "./splitArguments";
+
+// `restore .` rewrites every path, staged or in the working tree, so the staged form is refused as the plain one is
+export const getRestoreRefusal = (args: string[]): string | undefined => {
+  const { flags, operands } = splitArguments(args);
+  if (!isWholeCheckout(operands)) return undefined;
+  const isStaged = flags.some((flag) => flag === "--staged" || flag === "-S");
+  return `git restore ${isStaged ? "--staged " : ""}.`;
+};

package/src/services/ward/getStashRefusal.ts

@@ -0,0 +1,2 @@
+// A stash in any form sets a peer's work aside, which is why the git skill never runs one
+export const getStashRefusal = (): string => "git stash";

package/src/services/ward/getSubcommand.ts

@@ -0,0 +1,16 @@
+import { isFlag } from "./isFlag";
+
+// The options git takes before its subcommand, each with its value as the next word
+const GIT_VALUE_OPTIONS: ReadonlySet<string> = new Set(["--git-dir", "--namespace", "--work-tree", "-C", "-c"]);
+
+// The subcommand past the options git takes before it, the arguments after the subcommand, and the folders its `-C`
+// Options name, each from the one before
+export const getSubcommand = (args: string[]) => {
+  const directories: string[] = [];
+  let index = 0;
+  while (index < args.length && isFlag(args[index] ?? "")) {
+    if (args[index] === "-C") directories.push(args[index + 1] ?? "");
+    index += GIT_VALUE_OPTIONS.has(args[index] ?? "") ? 2 : 1;
+  }
+  return { arguments: args.slice(index + 1), directories, name: args[index] ?? "" };
+};

package/src/services/ward/getWholeIndexDenyReason.ts

@@ -0,0 +1,9 @@
+// The path-scoped forms that do the same job for the paths the session touched, named for the person's shared checkout
+export const getWholeIndexDenyReason = (form: string, peerPath: string): string =>
+  [
+    `Refused: \`${form}\` reaches the staged and working changes of another session in this checkout, which is editing ${peerPath} now. Name the paths you touched instead:`,
+    "- `git add <path>` to stage them;",
+    "- `git reset -- <path>` to unstage them;",
+    '- `git commit -m "…" -- <path>` to commit only them.',
+    "The git skill's rule (`.agents/skills/git/SKILL.md`) owns the whole-index list.",
+  ].join("\n");

package/src/services/ward/getWholeIndexRefusal.ts

@@ -1,127 +1,7 @@
-import type { CommandRefusal } from "../shell/getShellRefusal";
-
 import { getShellRefusal } from "../shell/getShellRefusal";
-import { joinDirectory } from "../shell/joinDirectory";
-
-const GIT_NAMES: ReadonlySet<string> = new Set(["git", "git.exe"]);
-
-// The options git takes before its subcommand, each with its value as the next word
-const GIT_VALUE_OPTIONS: ReadonlySet<string> = new Set(["-C", "-c"]);
-
-// The reset modes that touch the working tree or the index beyond HEAD, so a reset with one of them is not a commit move
-const RESET_INDEX_MODES: ReadonlySet<string> = new Set(["--hard", "--keep", "--merge", "--mixed"]);
-
-const ADD_ALL_FLAGS: ReadonlySet<string> = new Set(["--all", "--update", "-A", "-u"]);
-
-// The pathspecs git reads as every path of the checkout, from its root or the folder the command runs in
-const WHOLE_CHECKOUT_PATHSPECS: ReadonlySet<string> = new Set([".", "./", ":/", ":/."]);
-
-const isFlag = (arg: string) => arg.startsWith("-");
-
-const isWholeCheckout = (operands: string[]) => operands.some((operand) => WHOLE_CHECKOUT_PATHSPECS.has(operand));
-
-// The flags, the words before a `--` and the words after it, so a path is read whether or not git was given a separator
-const splitArguments = (args: string[]) => {
-  const separator = args.indexOf("--");
-  const before = separator === -1 ? args : args.slice(0, separator);
-  const after = separator === -1 ? [] : args.slice(separator + 1);
-  return {
-    after,
-    flags: before.filter((arg) => isFlag(arg)),
-    hasSeparator: separator !== -1,
-    operands: [...before.filter((arg) => !isFlag(arg)), ...after],
-  };
-};
-
-// The subcommand past the options git takes before it, the arguments after the subcommand, and the folders its `-C`
-// Options name, each from the one before
-const getSubcommand = (args: string[]) => {
-  const directories: string[] = [];
-  let index = 0;
-  while (index < args.length && isFlag(args[index] ?? "")) {
-    if (args[index] === "-C") directories.push(args[index + 1] ?? "");
-    index += GIT_VALUE_OPTIONS.has(args[index] ?? "") ? 2 : 1;
-  }
-  return { arguments: args.slice(index + 1), directories, name: args[index] ?? "" };
-};
-
-// `add .`, `add -A` and `add -N` over every path reach a peer's work, while a named path does not
-const getAddRefusal = (args: string[]): string | undefined => {
-  const { flags, operands } = splitArguments(args);
-  if (isWholeCheckout(operands)) return "git add .";
-  const allFlag = flags.find((flag) => ADD_ALL_FLAGS.has(flag));
-  if (allFlag !== undefined && operands.length === 0) return `git add ${allFlag}`;
-  const isIntentToAdd = flags.some((flag) => flag === "-N" || flag === "--intent-to-add");
-  return isIntentToAdd && operands.length === 0 ? "git add -N" : undefined;
-};
-
-// A reset that names a path is path-scoped: after `--`, or as a second operand with none, since git reads the first
-// As a commit or a path and every one after it as a path. The checkout's own pathspec names no commit, so it is the
-// Whole checkout in either place. A lone operand may be a commit, so it is refused, and a reset that moves HEAD alone
-// With `--soft` leaves the index as it is; every other reset rewrites the index to HEAD or the working tree, a peer's
-// Staged entries included
-const getResetRefusal = (args: string[]): string | undefined => {
-  const { after, flags, hasSeparator, operands } = splitArguments(args);
-  if (isWholeCheckout(hasSeparator ? after : operands)) return "git reset -- .";
-  const paths = hasSeparator ? after : operands.slice(1);
-  if (paths.length > 0) return undefined;
-  const isSoftOnly = flags.includes("--soft") && !flags.some((flag) => RESET_INDEX_MODES.has(flag));
-  return isSoftOnly ? undefined : "git reset";
-};
-
-// `restore .` rewrites every path, staged or in the working tree, so the staged form is refused as the plain one is
-const getRestoreRefusal = (args: string[]): string | undefined => {
-  const { flags, operands } = splitArguments(args);
-  if (!isWholeCheckout(operands)) return undefined;
-  const isStaged = flags.some((flag) => flag === "--staged" || flag === "-S");
-  return `git restore ${isStaged ? "--staged " : ""}.`;
-};
-
-// A stash in any form sets a peer's work aside, which is why the git skill never runs one
-const getStashRefusal = (): string => "git stash";
-
-// `checkout .` and `checkout -- .` overwrite every path's working tree copy, a peer's edits included
-const getCheckoutRefusal = (args: string[]): string | undefined =>
-  isWholeCheckout(splitArguments(args).operands) ? "git checkout ." : undefined;
-
-// A clean deletes every untracked file, a peer's new ones included; a dry run lists them and is allowed
-const getCleanRefusal = (args: string[]): string | undefined => {
-  const { flags } = splitArguments(args);
-  const isDryRun = flags.some((flag) => flag === "--dry-run" || (!flag.startsWith("--") && flag.includes("n")));
-  return isDryRun ? undefined : "git clean";
-};
-
-const WHOLE_INDEX_REFUSALS: ReadonlyMap<string, (args: string[]) => string | undefined> = new Map([
-  ["add", getAddRefusal],
-  ["checkout", getCheckoutRefusal],
-  ["clean", getCleanRefusal],
-  ["reset", getResetRefusal],
-  ["restore", getRestoreRefusal],
-  ["stash", getStashRefusal],
-]);
-
-// The form refused and the folder git runs in, from the session's ("" for the session's own): the folder a `cd` before
-// It moved to, then each of its `-C` folders
-const getGitRefusal: CommandRefusal<{ directory: string; form: string }> = (name, args, directory) => {
-  if (!GIT_NAMES.has(name)) return undefined;
-  const subcommand = getSubcommand(args);
-  const form = WHOLE_INDEX_REFUSALS.get(subcommand.name)?.(subcommand.arguments);
-  return form === undefined
-    ? undefined
-    : { directory: subcommand.directories.reduce((base, next) => joinDirectory(base, next), directory), form };
-};
+import { getGitRefusal } from "./getGitRefusal";
 
 // The whole-index git form a Bash command runs, named as the form it is, with the folder it runs in, undefined for a
 // Path-scoped or read-only command
 export const getWholeIndexRefusal = (command: string): undefined | { directory: string; form: string } =>
   getShellRefusal(command, getGitRefusal);
-
-// The path-scoped forms that do the same job for the paths the session touched, named for the person's shared checkout
-export const getWholeIndexDenyReason = (form: string, peerPath: string): string =>
-  [
-    `Refused: \`${form}\` reaches the staged and working changes of another session in this checkout, which is editing ${peerPath} now. Name the paths you touched instead:`,
-    "- `git add <path>` to stage them;",
-    "- `git reset -- <path>` to unstage them;",
-    '- `git commit -m "…" -- <path>` to commit only them.',
-    "The git skill's rule (`.agents/skills/git/SKILL.md`) owns the whole-index list.",
-  ].join("\n");

package/src/services/ward/isFlag.ts

@@ -0,0 +1 @@
+export const isFlag = (arg: string) => arg.startsWith("-");

package/src/services/ward/isWholeCheckout.ts

@@ -0,0 +1,5 @@
+// The pathspecs git reads as every path of the checkout, from its root or the folder the command runs in
+const WHOLE_CHECKOUT_PATHSPECS: ReadonlySet<string> = new Set([".", "./", ":/", ":/."]);
+
+export const isWholeCheckout = (operands: string[]) =>
+  operands.some((operand) => WHOLE_CHECKOUT_PATHSPECS.has(operand));

package/src/services/ward/registerWholeIndex.ts

@@ -6,7 +6,8 @@ import { InitialState } from "../InitialState";
 import { joinDirectory } from "../shell/joinDirectory";
 import { getCheckoutPeer } from "./getCheckoutPeer";
 import { getParentFolder } from "./getParentFolder";
-import { getWholeIndexDenyReason, getWholeIndexRefusal } from "./getWholeIndexRefusal";
+import { getWholeIndexDenyReason } from "./getWholeIndexDenyReason";
+import { getWholeIndexRefusal } from "./getWholeIndexRefusal";
 import { readRecords } from "./readRecords";
 import { resolveRecordsPath } from "./resolveRecordsPath";