@xbzbing/dsh-git-panel 1.6.1 → 1.7.0

package/lib/host/suggest.d.ts

@@ -1,4 +1,36 @@
 import type { GitPanelConfig, SnapshotDeps } from './core.js';
-import type { GitSuggestRequest, GitSuggestResult } from './types.js';
+import type { GitSuggestRequest, GitSuggestResult, ResolvedLanguage, SuggestLanguage } from './types.js';
+export declare function isCjkText(text: string): boolean;
+/**
+ * Parse `git log -z --format=%ae%x1f%s` into the repository's own commit
+ * subjects, newest first: mechanical commits dropped, and the current
+ * author's commits preferred once they are numerous enough to represent the
+ * repository (a shared checkout may mix identities). Subjects are trimmed to
+ * `STYLE_SAMPLE_MAX_CHARS` code points so one runaway subject cannot consume
+ * the generation budget; the closest commit's language still dominates.
+ */
+export declare function parseStyleHistory(stdout: string, ownEmail: string | undefined): string[];
+/**
+ * Resolve the language a suggestion is written in. `zh` / `en` are honored as
+ * configured; `auto` votes over the repository's recent non-mechanical commit
+ * subjects with a recency decay, so a repository that switched languages is
+ * judged by how it writes *now* rather than by its whole history. With no
+ * history to read (an unborn repository) the vote is empty and English is the
+ * neutral fallback.
+ */
+export declare function resolveSuggestLanguage(setting: SuggestLanguage, samples: readonly string[]): ResolvedLanguage;
+/** A diff line longer than this is replaced by a one-line marker before the
+ * model-input budget is applied. Build output is minified into single lines (a
+ * bundled `lib/client.js` line can be hundreds of KB), so shipping it verbatim
+ * spends the whole `suggestMaxBytes` budget on one line and cuts off the hunks
+ * that actually describe the change. Line count and the diff prefix are kept,
+ * so `@@` headers still describe the same regions. */
+export declare const LONG_LINE_MAX_CHARS = 400;
+/** Fold over-long lines into `<prefix>… [long line: N chars omitted]`.
+ * `N` counts UTF-16 code units (what `String.length` reports), not bytes. */
+export declare function compactLongLines(text: string, maxChars?: number): {
+    text: string;
+    folded: number;
+};
 /** Generate a commit message for the session's uncommitted changes. */
 export declare function runSuggest(deps: SnapshotDeps, config: GitPanelConfig, request: GitSuggestRequest): Promise<GitSuggestResult>;

package/lib/host/suggest.js

@@ -1,15 +1,65 @@
 import { mapWorkspaceFailure, resolveWorkspace, runCommand } from "./core.js";
 import { isSafePath } from "./validate.js";
 import { parseStatus } from "./parser.js";
-const SYSTEM_PROMPT = [
-  "You are an expert at writing concise, accurate git commit messages.",
-  "Given a repository\u2019s uncommitted changes, write ONE commit message for them.",
-  "The message must start with a short imperative subject line (72 chars max), optionally followed by a blank line and a brief body explaining what changed and why.",
-  "Return only the message text: no quotes, code fences, prefixes, bullet lists, or explanations.",
-  "Match the language and style of the recent commit message when one is provided; otherwise write in English.",
-  "Focus on the most important change; do not mechanically list every file."
-].join("\n");
+const HISTORY_SCAN = 60;
+const STYLE_SAMPLE_CAP = 12;
+const STYLE_SAMPLE_MAX_CHARS = 200;
+const OWN_AUTHOR_MIN = 3;
+const LANGUAGE_DECAY = 0.9;
+const MECHANICAL_SUBJECT = /^(chore: release|merged?\b|revert\b|fixup!|squash!)/i;
+const CJK = /[\u4e00-\u9fff]/;
+function isCjkText(text) {
+  return CJK.test(text);
+}
+function parseStyleHistory(stdout, ownEmail) {
+  const records = [];
+  for (const record of stdout.split("\0")) {
+    const sep = record.indexOf("");
+    if (sep === -1) continue;
+    const subject = record.slice(sep + 1).trim();
+    if (subject === "" || MECHANICAL_SUBJECT.test(subject)) continue;
+    records.push({ email: record.slice(0, sep), subject });
+  }
+  const own = ownEmail === void 0 || ownEmail === "" ? [] : records.filter((r) => r.email === ownEmail);
+  const pool = own.length >= OWN_AUTHOR_MIN ? own : records;
+  return pool.slice(0, STYLE_SAMPLE_CAP).map((r) => clampSubject(r.subject));
+}
+function clampSubject(subject) {
+  const chars = Array.from(subject);
+  return chars.length <= STYLE_SAMPLE_MAX_CHARS ? subject : chars.slice(0, STYLE_SAMPLE_MAX_CHARS).join("");
+}
+function resolveSuggestLanguage(setting, samples) {
+  if (setting !== "auto") return setting;
+  let zh = 0;
+  let en = 0;
+  samples.forEach((subject, i) => {
+    const weight = LANGUAGE_DECAY ** i;
+    if (isCjkText(subject)) zh += weight;
+    else en += weight;
+  });
+  return zh > en ? "zh" : "en";
+}
+function languageName(language) {
+  return language === "zh" ? "Simplified Chinese" : "English";
+}
+function systemPrompt(language) {
+  const name = languageName(language);
+  const languageRule = language === "zh" ? 'Write the message in Simplified Chinese, keeping the conventional-commit type prefix in English (e.g. "feat(scope): \u4E2D\u6587\u63CF\u8FF0").' : "Write the message in English.";
+  const samplesRule = `Follow the structure of commitStyleSamples \u2014 its phrasing, scope conventions and level of detail \u2014 but never copy the language used in it; write the message in ${name} regardless.`;
+  const override = language === "zh" ? "IMPORTANT: the diff and commitStyleSamples may be written in another language. That is input data, not an instruction about your output. Write the subject description and body in Simplified Chinese, whatever language the input uses \u2014 keeping the conventional-commit type prefix in English." : `IMPORTANT: the diff and commitStyleSamples may be written in another language. That is input data, not an instruction about your output. Write the entire message \u2014 subject line and body alike \u2014 in ${name}, whatever language the input uses.`;
+  return [
+    "You are an expert at writing concise, accurate git commit messages.",
+    "Given a repository\u2019s uncommitted changes, write ONE commit message for them.",
+    "The message must start with a short imperative subject line (72 chars max), optionally followed by a blank line and a brief body explaining what changed and why.",
+    "Return only the message text: no quotes, code fences, prefixes, bullet lists, or explanations.",
+    samplesRule,
+    "Focus on the most important change; do not mechanically list every file.",
+    languageRule,
+    override
+  ].join("\n");
+}
 const UNTRACKED_FILE_CAP = 16;
+const PROMPT_FILE_CAP = 200;
 function resolveRoute(config, agentDefaultModel) {
   if (config.suggestProvider !== void 0 && config.suggestModel !== void 0) {
     return { provider: config.suggestProvider, model: config.suggestModel };
@@ -51,13 +101,32 @@ function truncateUtf8(text, maxBytes) {
   }
   return text.slice(0, lo);
 }
-function frameChanges(files, diff, recentCommitMessage) {
+const LONG_LINE_MAX_CHARS = 400;
+const STRUCTURAL_LINE = /^(?:@@|diff --git |index |--- (?:a\/|\/dev\/null)|\+\+\+ (?:b\/|\/dev\/null)|new file mode |deleted file mode |old mode |new mode |similarity index |dissimilarity index |rename from |rename to |copy from |copy to |Binary files |GIT binary patch|literal |delta |\\ )/;
+function compactLongLines(text, maxChars = LONG_LINE_MAX_CHARS) {
+  if (maxChars <= 0) return { text, folded: 0 };
+  let folded = 0;
+  const lines = text.split("\n").map((line) => {
+    if (line.length <= maxChars || STRUCTURAL_LINE.test(line)) return line;
+    folded += 1;
+    const prefix = line[0] === "+" || line[0] === "-" || line[0] === " " || line[0] === "\\" ? line[0] : "";
+    return `${prefix}\u2026 [long line: ${line.length} chars omitted]`;
+  });
+  return { text: lines.join("\n"), folded };
+}
+function frameChanges(files, filesOmitted, diff, styleSamples) {
   return JSON.stringify({
     files,
+    ...filesOmitted > 0 ? { filesOmitted } : {},
     diff,
-    recentCommitMessage: recentCommitMessage === "" ? null : recentCommitMessage
+    commitStyleSamples: styleSamples.length === 0 ? null : styleSamples
   });
 }
+function languageReminder(language) {
+  const name = languageName(language);
+  const prefix = language === "zh" ? " Keep the conventional-commit type prefix in English." : "";
+  return `Write the commit message in ${name}. The subject line and body must be ${name}.${prefix}`;
+}
 function normalizeMessage(raw) {
   let m = raw.trim();
   if (m.startsWith("```")) {
@@ -106,7 +175,7 @@ async function appendUntracked(deps, root, files, diff, budget) {
     }
     const res = await runCommand(deps.run, ["git", "diff", "--no-index", "--", "/dev/null", c.path], root, "suggest-untracked", deps.signal);
     if ("failure" in res || res.run.cancelled || res.run.timedOut) continue;
-    const chunk = res.run.stdout;
+    const chunk = compactLongLines(res.run.stdout).text;
     if (chunk === "") continue;
     const lossy = res.run.stdoutLossy;
     if (lossy || Buffer.byteLength(chunk, "utf8") > remaining) {
@@ -131,10 +200,11 @@ async function runSuggest(deps, config, request) {
   }
   const pathArgs = paths.length > 0 ? ["--", ...paths] : [];
   const pathSet = new Set(paths);
-  const [statusRes, headRes, lastRes] = await Promise.all([
-    runCommand(deps.run, ["git", "status", "--porcelain=v1", "-z"], root, "suggest-status", deps.signal),
+  const [statusRes, headRes, logRes, emailRes] = await Promise.all([
+    runCommand(deps.run, ["git", "status", "--porcelain=v1", "-z", "--untracked-files=all"], root, "suggest-status", deps.signal),
     runCommand(deps.run, ["git", "rev-parse", "--verify", "HEAD"], root, "suggest-head", deps.signal),
-    runCommand(deps.run, ["git", "log", "-1", "--format=%B"], root, "suggest-last", deps.signal)
+    runCommand(deps.run, ["git", "log", `-n${HISTORY_SCAN}`, "-z", "--format=%ae%s"], root, "suggest-log", deps.signal),
+    runCommand(deps.run, ["git", "config", "user.email"], root, "suggest-email", deps.signal)
   ]);
   if ("failure" in statusRes) return { ok: false, error: { code: "git-unavailable", message: "status failed" } };
   if (statusRes.run.cancelled) return { ok: false, error: { code: "cancelled" } };
@@ -143,15 +213,22 @@ async function runSuggest(deps, config, request) {
     return { ok: false, error: { code: "git-error", message: statusRes.run.stderr.trim() || "git status failed" } };
   }
   const hasHead = "run" in headRes && headRes.run.exitCode === 0;
-  const recentCommitMessage = "run" in lastRes && lastRes.run.exitCode === 0 ? lastRes.run.stdout.replace(/\n+$/, "") : "";
+  const styleSamples = "run" in logRes && logRes.run.exitCode === 0 ? parseStyleHistory(logRes.run.stdout, "run" in emailRes && emailRes.run.exitCode === 0 ? emailRes.run.stdout.trim() : void 0) : [];
+  const language = resolveSuggestLanguage(config.suggestLanguage, styleSamples);
   const all = statusRes.run.stdoutLossy ? [] : parseStatus(statusRes.run.stdout);
-  const files = pathSet.size > 0 ? all.filter((c) => pathSet.has(c.path)) : all;
+  const files = pathSet.size > 0 ? all.filter((c) => {
+    if (pathSet.has(c.path)) return true;
+    for (let slash = c.path.indexOf("/"); slash !== -1; slash = c.path.indexOf("/", slash + 1)) {
+      if (pathSet.has(c.path.slice(0, slash))) return true;
+    }
+    return false;
+  }) : all;
   const collected = await collectDiff(deps, root, hasHead, pathArgs);
   if (!("diff" in collected)) return collected;
   if (files.length === 0 && collected.diff.trim() === "") {
     return { ok: false, error: { code: "empty-diff", message: "no uncommitted changes to summarize" } };
   }
-  let diff = collected.diff;
+  let diff = compactLongLines(collected.diff).text;
   let truncated = collected.lossy;
   if (Buffer.byteLength(diff, "utf8") > config.suggestMaxBytes) {
     diff = truncateUtf8(diff, config.suggestMaxBytes) + "\n... [diff truncated]";
@@ -166,19 +243,23 @@ async function runSuggest(deps, config, request) {
     return { ok: false, error: { code: "llm-unavailable", message: "no model service or route is configured" } };
   }
   const frame = frameChanges(
-    files.map((c) => ({ path: c.path, status: c.status })),
+    files.slice(0, PROMPT_FILE_CAP).map((c) => ({ path: c.path, status: c.status })),
+    Math.max(0, files.length - PROMPT_FILE_CAP),
     diff,
-    recentCommitMessage
+    styleSamples
   );
   const deadline = withDeadline(config.suggestTimeoutMs, deps.signal);
   const options = {
     provider: route.provider,
     model: route.model,
-    system: SYSTEM_PROMPT,
+    system: systemPrompt(language),
     messages: [{
       id: "git-panel-suggest",
       role: "user",
-      content: [{ type: "text", text: frame }],
+      content: [
+        { type: "text", text: frame },
+        { type: "text", text: languageReminder(language) }
+      ],
       source: { kind: "user" }
     }],
     maxTokens: config.suggestMaxOutputTokens,
@@ -216,5 +297,10 @@ async function runSuggest(deps, config, request) {
   };
 }
 export {
+  LONG_LINE_MAX_CHARS,
+  compactLongLines,
+  isCjkText,
+  parseStyleHistory,
+  resolveSuggestLanguage,
   runSuggest
 };

package/lib/host/types.d.ts

@@ -72,6 +72,9 @@ export interface GitRemote {
     /** Known-host classification, for the status-bar icon. */
     readonly hostKind: RemoteHostKind;
 }
+/** Why the change list is incomplete: capped at `maxChanges`, or the status
+ * stream itself was clipped (a lossy read drops the head). */
+export type TruncationReason = 'cap' | 'lossy';
 /** Immutable snapshot of one repository's status at `checkedAt`. */
 export interface GitSnapshot {
     /** Realpath of the repository root (work tree top). */
@@ -97,8 +100,14 @@ export interface GitSnapshot {
     readonly changes: readonly GitChange[];
     /** Working-tree statistics for the changes-page header (single source). */
     readonly stats: WorktreeStats;
-    /** True when the change list was capped at maxChanges. */
+    /** True when the change list is incomplete (capped or clipped). */
     readonly truncated: boolean;
+    /** Which limit produced `truncated`; absent on older hosts. */
+    readonly truncatedReason?: TruncationReason;
+    /** True when untracked files fell back to git's collapsed `?? dir/` entries
+     * because expanding them would overflow `maxChanges` (or the status stream).
+     * Older hosts never set it. */
+    readonly untrackedCollapsed?: boolean;
     /** Polling interval the client should use after this snapshot (0 = off). */
     readonly refreshIntervalMs: number;
     /** Whether the input-bar git marker pill should render (user preference). */
@@ -109,6 +118,9 @@ export interface GitSnapshot {
     readonly graphStyle: GraphStyle;
     /** Whether the commit box shows the AI-suggest button (user preference). */
     readonly suggestEnabled: boolean;
+    /** SHA-256 of the final business snapshot, excluding checkedAt and itself.
+     * Optional for compatibility with hosts that do not provide fingerprints. */
+    readonly stateFingerprint?: string;
     /** Epoch millis of the snapshot. */
     readonly checkedAt: number;
 }
@@ -119,9 +131,15 @@ export interface GitCommit {
     readonly author: string;
     readonly dateIso: string;
 }
-/** A commit with parent links and ref decorations (graph rendering). */
-export interface GraphCommit extends GitCommit {
+/** One node of the commit graph's raw ancestry: a full hash and its raw parent
+ * hashes. `parents` is empty for a true root — and equally for a shallow
+ * boundary, which git cannot tell apart from a root. */
+export interface GitGraphNode {
+    readonly hash: string;
     readonly parents: readonly string[];
+}
+/** A commit with parent links and ref decorations (graph rendering). */
+export interface GraphCommit extends GitCommit, GitGraphNode {
     readonly refs: readonly GitRef[];
 }
 export interface GitRef {
@@ -210,7 +228,7 @@ export type GitAction = {
 /** `git reset` modes, from least to most destructive. Single source so the
  * client dialog and the command builder cannot drift. */
 export type ResetMode = 'soft' | 'mixed' | 'hard';
-export type GitErrorCode = 'cwd-unavailable' | 'not-a-git-repo' | 'git-unavailable' | 'invalid-path' | 'invalid-name' | 'invalid-index' | 'git-error' | 'timeout' | 'cancelled' | 'empty-message' | 'local-changes-block' | 'not-ff' | 'push-rejected' | 'auth-failed' | 'conflict' | 'revert-conflict' | 'revert-stuck' | 'revert-merge' | 'not-found' | 'branch-in-use' | 'stash-switch-failed' | 'index-busy' | 'empty-diff' | 'llm-unavailable' | 'llm-error' | 'llm-output' | 'suggest-disabled';
+export type GitErrorCode = 'cwd-unavailable' | 'not-a-git-repo' | 'git-unavailable' | 'invalid-path' | 'invalid-name' | 'invalid-index' | 'git-error' | 'timeout' | 'cancelled' | 'empty-message' | 'local-changes-block' | 'not-ff' | 'push-rejected' | 'auth-failed' | 'conflict' | 'revert-conflict' | 'revert-stuck' | 'revert-merge' | 'not-found' | 'branch-in-use' | 'stash-switch-failed' | 'index-busy' | 'nested-repo' | 'nested-repo-partial' | 'empty-diff' | 'llm-unavailable' | 'llm-error' | 'llm-output' | 'suggest-disabled';
 export type GitActionResult = {
     readonly ok: true;
     readonly snapshot: GitSnapshot;
@@ -226,6 +244,16 @@ export interface GitActionRequest {
     readonly sessionId: string;
     readonly action: GitAction;
 }
+/**
+ * True when a history `search` is a commit-hash prefix jump rather than a
+ * message regex: 7–40 hex chars after trimming.
+ */
+export declare function isHistoryHashSearch(search: string): boolean;
+/** Whether Git's effective content filters hide commits; hash jumps ignore them.
+ * Shared with clients receiving history from a host that omits topology. */
+export declare function isHistoryFiltered(query: Pick<Extract<GitQuery, {
+    kind: 'history';
+}>, 'search' | 'author' | 'since'>): boolean;
 export type GitQuery = {
     readonly kind: 'history';
     readonly limit: number;
@@ -357,6 +385,11 @@ export type GitQueryResult = {
     readonly kind: 'history';
     readonly commits: readonly GraphCommit[];
     readonly total: number;
+    /** Raw ancestry for a filtered page: the page's commits plus the ancestors
+     * an effective search/author/since filter hid from the page itself. Absent
+     * when no effective filter is active (or on a hash jump); `[]` means the
+     * bounded auxiliary walk failed, so the graph is incomplete. */
+    readonly topology?: readonly GitGraphNode[];
 }
 /**
  * Unified diff text plus the new-side line count. The count is the fact the
@@ -372,10 +405,13 @@ export type GitQueryResult = {
  * trailing gap rather than a speculative one.
  *
  * `truncated` marks the one case where the text itself is incomplete: the
- * runner dropped output at its collect/spill ceiling, so `text` is a prefix
- * that still parses like a real diff. It is flagged rather than refused —
- * the partial hunks stay readable — but the view must say so, because line
- * numbers and +/- counts past the cut are simply wrong.
+ * runner dropped output at its collect/spill ceiling, which discards the
+ * *head* of the stream, so `text` is a tail that still parses like a real
+ * diff — the surviving hunks carry git's own line numbers — while the header
+ * and opening hunks are gone and the +/- counts under-report. It is flagged
+ * rather than refused (the partial hunks stay readable), but the view must say
+ * so: it would otherwise present the lost opening as ordinary folded context,
+ * as if the diff were whole.
  */
  | {
     readonly kind: 'diff';
@@ -478,6 +514,14 @@ export type GitQueryResult = {
     /** Modification time (epoch ms) from the same stat (all variants). */
     readonly mtimeMs?: number;
 };
+/**
+ * Byte envelope of the file browser's "copy file content" action: a text
+ * document is copyable strictly below this size. Shared by both halves —
+ * the host floors its text read here (so every copyable document can
+ * actually load) and the client hides the copy button at/above it, keeping
+ * one boundary for load and copy.
+ */
+export declare const FILE_COPY_MAX_BYTES: number;
 export type GitQueryResponse = {
     readonly ok: true;
     readonly value: GitQueryResult;
@@ -517,6 +561,18 @@ export declare const SUGGEST_LIMITS: {
         readonly default: 15000;
     };
 };
+/**
+ * Selectable commit-message languages. `auto` infers the language from the
+ * repository's own commit history (see resolveSuggestLanguage); `zh` / `en`
+ * pin it. Shared by both halves like SUGGEST_LIMITS — the detail-page form
+ * renders one segment per entry.
+ */
+export declare const SUGGEST_LANGUAGES: readonly ["auto", "zh", "en"];
+export type SuggestLanguage = (typeof SUGGEST_LANGUAGES)[number];
+/** Default is `auto`: follow the style the repository is already written in. */
+export declare const SUGGEST_LANGUAGE_DEFAULT: SuggestLanguage;
+/** A language a suggestion is actually written in — `auto` is always resolved. */
+export type ResolvedLanguage = Exclude<SuggestLanguage, 'auto'>;
 /**
  * Wire request for the suggest endpoint: ask the configured model to write a
  * commit message from the repository's uncommitted changes. `paths` restricts

package/lib/host/types.js

@@ -2,11 +2,21 @@ const DIFF_CONTEXT_DEFAULT = 3;
 const DIFF_CONTEXT_MAX = 1e5;
 const DIFF_EXPAND_CONTEXT = 2e3;
 const DIFF_COUNT_READ_MAX = 8 * 1024 * 1024;
+function isHistoryHashSearch(search) {
+  return /^[0-9a-fA-F]{7,40}$/.test(search.trim());
+}
+function isHistoryFiltered(query) {
+  const search = query.search?.trim() ?? "";
+  return !isHistoryHashSearch(search) && (search !== "" || (query.author ?? "") !== "" || (query.since ?? "") !== "");
+}
+const FILE_COPY_MAX_BYTES = 10 * 1024 * 1024;
 const SUGGEST_LIMITS = {
-  maxBytes: { min: 16 * 1024, max: 512 * 1024, default: 128 * 1024 },
+  maxBytes: { min: 16 * 1024, max: 512 * 1024, default: 200 * 1024 },
   maxOutputTokens: { min: 256, max: 16384, default: 4096 },
   timeoutMs: { min: 5e3, max: 12e4, default: 15e3 }
 };
+const SUGGEST_LANGUAGES = ["auto", "zh", "en"];
+const SUGGEST_LANGUAGE_DEFAULT = "auto";
 const IMAGE_MIME = {
   png: "image/png",
   jpg: "image/jpeg",
@@ -30,7 +40,12 @@ export {
   DIFF_CONTEXT_MAX,
   DIFF_COUNT_READ_MAX,
   DIFF_EXPAND_CONTEXT,
+  FILE_COPY_MAX_BYTES,
   IMAGE_MIME,
+  SUGGEST_LANGUAGES,
+  SUGGEST_LANGUAGE_DEFAULT,
   SUGGEST_LIMITS,
-  imageMimeFor
+  imageMimeFor,
+  isHistoryFiltered,
+  isHistoryHashSearch
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xbzbing/dsh-git-panel",
-  "version": "1.6.1",
+  "version": "1.7.0",
   "description": "DeepSeek Harness (dsh) plugin: an IDE-style Git panel in the Web GUI — branch/history overview, uncommitted changes with commit & amend, diff stats, and a zsh-style branch marker in the input bar.",
   "type": "module",
   "license": "MIT",
@@ -43,7 +43,7 @@
     "build": "node build.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test:unit": "node build.mjs && node --test --test-force-exit test/unit/*.test.mjs",
-    "test:e2e": "node build.mjs && node test/e2e/setup.mjs && node test/e2e/run.mjs && node test/e2e/run2.mjs && node test/e2e/run3.mjs && node test/e2e/run4.mjs && node test/e2e/run5.mjs",
+    "test:e2e": "node build.mjs && node test/e2e/setup.mjs && node test/e2e/all.mjs",
     "test": "npm run test:unit && npm run test:e2e",
     "check": "npm run typecheck && npm run test && git diff --exit-code -- lib/"
   },