@systemdox/mcp-server 0.1.45 → 0.1.47

package/dist/install-skill.js

@@ -34,6 +34,28 @@ var ResponseCache = class {
 };
 
 // src/lib/api-client.ts
+var SystemDoxApiError = class extends Error {
+  constructor(status, text) {
+    super(`SystemDox API error ${status}: ${text}`);
+    this.status = status;
+    this.text = text;
+    let body;
+    try {
+      body = JSON.parse(text);
+    } catch {
+      body = void 0;
+    }
+    this.body = body;
+    const code = body?.code;
+    this.code = typeof code === "string" ? code : /\b(SYD-[A-Z]\d{3})\b/.exec(text)?.[1];
+  }
+  status;
+  text;
+  code;
+  body;
+};
+var TEAM_SETUP = "/v1/team-setup";
+var seg = (s) => encodeURIComponent(String(s));
 var SystemDoxApiClient = class {
   config;
   cache;
@@ -55,10 +77,7 @@ var SystemDoxApiClient = class {
     const cached = this.cache.get(cacheKey);
     if (cached !== void 0) return cached;
     const res = await this.fetchRaw(path, params);
-    if (!res.ok) {
-      const body = await res.text();
-      throw new Error(`SystemDox API error ${res.status}: ${body}`);
-    }
+    if (!res.ok) throw new SystemDoxApiError(res.status, await res.text());
     const data = await res.json();
     this.cache.set(cacheKey, data);
     return data;
@@ -67,10 +86,7 @@ var SystemDoxApiClient = class {
    * latest now, not the one cached before someone published another. */
   async getFresh(path) {
     const res = await this.fetchRaw(path);
-    if (!res.ok) {
-      const body = await res.text();
-      throw new Error(`SystemDox API error ${res.status}: ${body}`);
-    }
+    if (!res.ok) throw new SystemDoxApiError(res.status, await res.text());
     return await res.json();
   }
   async post(path, body) {
@@ -92,12 +108,101 @@ var SystemDoxApiClient = class {
       },
       body: JSON.stringify(body)
     });
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`SystemDox API error ${res.status}: ${text}`);
-    }
+    if (!res.ok) throw new SystemDoxApiError(res.status, await res.text());
     return await res.json();
   }
+  // ── Team setup (ADR-217, specs/changes/team-setup/openapi.yaml) ──────────
+  // One method per operationId. Every read skips the cache: setup, sync and
+  // plugin-path act on what the workspace holds now.
+  /** getOwnTeamSetup: the key's own workspace, named in `workspace`. */
+  getOwnTeamSetup() {
+    return this.getFresh(TEAM_SETUP);
+  }
+  getTeamSetup(workspace) {
+    return this.getFresh(`${TEAM_SETUP}/${seg(workspace)}`);
+  }
+  getMarketplace(workspace) {
+    return this.getFresh(`${TEAM_SETUP}/${seg(workspace)}/marketplace.json`);
+  }
+  getPart(workspace, part) {
+    return this.getFresh(`${TEAM_SETUP}/${seg(workspace)}/parts/${seg(part)}`);
+  }
+  publishPartVersion(workspace, part, files) {
+    return this.post(`${TEAM_SETUP}/${seg(workspace)}/parts/${seg(part)}/versions`, { files });
+  }
+  getPartVersion(workspace, part, version) {
+    return this.getFresh(
+      `${TEAM_SETUP}/${seg(workspace)}/parts/${seg(part)}/versions/${seg(version)}`
+    );
+  }
+  getSetupSkills(workspace) {
+    return this.getFresh(`${TEAM_SETUP}/${seg(workspace)}/skills`);
+  }
+  setSetupSkills(workspace, skills) {
+    return this.put(`${TEAM_SETUP}/${seg(workspace)}/skills`, { skills });
+  }
+  getPlugin(workspace) {
+    return this.getFresh(`${TEAM_SETUP}/${seg(workspace)}/plugin`);
+  }
+  /** getPluginZip: the zip's bytes as served, and its X-Content-SHA256
+   * header. The caller checks the BYTES against the hash it was given. */
+  async getPluginZip(workspace, version) {
+    const res = await fetch(
+      this.buildUrl(`${TEAM_SETUP}/${seg(workspace)}/plugin/versions/${seg(version)}/zip`),
+      {
+        headers: {
+          Authorization: `Bearer ${this.config.apiKey}`,
+          "X-API-Key": this.config.apiKey,
+          Accept: "application/zip"
+        }
+      }
+    );
+    if (!res.ok) throw new SystemDoxApiError(res.status, await res.text());
+    return { bytes: Buffer.from(await res.arrayBuffer()), sha256: res.headers.get("x-content-sha256") };
+  }
+  listMemoryProjects(workspace) {
+    return this.getFresh(`${TEAM_SETUP}/${seg(workspace)}/memory`);
+  }
+  getMemory(workspace, project) {
+    return this.getFresh(`${TEAM_SETUP}/${seg(workspace)}/memory/${seg(project)}`);
+  }
+  /** pushMemoryVersion: a stale base throws SystemDoxApiError with status 409,
+   * code SYD-K010 and `body.currentVersion`. */
+  pushMemoryVersion(workspace, project, body) {
+    return this.post(`${TEAM_SETUP}/${seg(workspace)}/memory/${seg(project)}/versions`, body);
+  }
+  getMemoryVersion(workspace, project, version) {
+    return this.getFresh(
+      `${TEAM_SETUP}/${seg(workspace)}/memory/${seg(project)}/versions/${seg(version)}`
+    );
+  }
+  findMissingBlobs(workspace, project, hashes) {
+    return this.post(
+      `${TEAM_SETUP}/${seg(workspace)}/memory/${seg(project)}/blobs/missing`,
+      { hashes }
+    );
+  }
+  uploadBlobs(workspace, project, blobs) {
+    return this.post(`${TEAM_SETUP}/${seg(workspace)}/memory/${seg(project)}/blobs`, { blobs });
+  }
+  readBlobs(workspace, project, hashes) {
+    return this.post(`${TEAM_SETUP}/${seg(workspace)}/memory/${seg(project)}/blobs/read`, { hashes });
+  }
+  listValueAnswers(workspace) {
+    return this.getFresh(`${TEAM_SETUP}/${seg(workspace)}/values`);
+  }
+  lookupValues(workspace, values) {
+    return this.post(`${TEAM_SETUP}/${seg(workspace)}/values`, { values });
+  }
+  answerValues(workspace, answers) {
+    return this.put(`${TEAM_SETUP}/${seg(workspace)}/values`, { answers });
+  }
+  fileMemoryPeople(workspace, people) {
+    return this.post(`${TEAM_SETUP}/${seg(workspace)}/people`, { people });
+  }
+  resolvePerson(workspace, personId) {
+    return this.getFresh(`${TEAM_SETUP}/${seg(workspace)}/people/${seg(personId)}`);
+  }
   invalidateCache(path) {
     if (path) {
       this.cache.invalidate(this.buildUrl(path).toString());

package/dist/lib/api-client.d.ts

@@ -1,4 +1,18 @@
 import type { ServerConfig } from "./config.js";
+import type { BlobRefusal, FileIn, FoundValue, Manifest, Marketplace, MemoryProjectSummary, MemoryVersion, PartDetail, PartName, PartPublished, PartVersionFiles, Person, PluginVersion, TeamSetup, ValueAnswer, ValueAnswerListed, ValueAnswerResults } from "./team-setup-types.js";
+/**
+ * A refused API call. The message keeps the form every caller has always
+ * shown (`SystemDox API error <status>: <body>`), so an SYD- code in the body
+ * reaches the user as the server wrote it; `code` and `body` are there for a
+ * caller that acts on one (a 409's `currentVersion`, a 503's SYD-K019).
+ */
+export declare class SystemDoxApiError extends Error {
+    readonly status: number;
+    readonly text: string;
+    readonly code: string | undefined;
+    readonly body: unknown;
+    constructor(status: number, text: string);
+}
 export declare class SystemDoxApiClient {
     private config;
     private cache;
@@ -11,6 +25,73 @@ export declare class SystemDoxApiClient {
     post<T>(path: string, body: unknown): Promise<T>;
     put<T>(path: string, body: unknown): Promise<T>;
     private mutate;
+    /** getOwnTeamSetup: the key's own workspace, named in `workspace`. */
+    getOwnTeamSetup(): Promise<TeamSetup>;
+    getTeamSetup(workspace: string): Promise<TeamSetup>;
+    getMarketplace(workspace: string): Promise<Marketplace>;
+    getPart(workspace: string, part: PartName): Promise<PartDetail>;
+    publishPartVersion(workspace: string, part: PartName, files: FileIn[]): Promise<PartPublished>;
+    getPartVersion(workspace: string, part: PartName, version: number | "latest"): Promise<PartVersionFiles>;
+    getSetupSkills(workspace: string): Promise<{
+        skills: string[];
+    }>;
+    setSetupSkills(workspace: string, skills: string[]): Promise<{
+        skills: string[];
+    }>;
+    getPlugin(workspace: string): Promise<{
+        name: string;
+        versions: PluginVersion[];
+    }>;
+    /** getPluginZip: the zip's bytes as served, and its X-Content-SHA256
+     * header. The caller checks the BYTES against the hash it was given. */
+    getPluginZip(workspace: string, version: number | "latest"): Promise<{
+        bytes: Buffer;
+        sha256: string | null;
+    }>;
+    listMemoryProjects(workspace: string): Promise<{
+        projects: MemoryProjectSummary[];
+    }>;
+    getMemory(workspace: string, project: string): Promise<MemoryVersion>;
+    /** pushMemoryVersion: a stale base throws SystemDoxApiError with status 409,
+     * code SYD-K010 and `body.currentVersion`. */
+    pushMemoryVersion(workspace: string, project: string, body: {
+        baseVersion: number;
+        manifest: Manifest;
+        spaceId?: string;
+    }): Promise<MemoryVersion>;
+    getMemoryVersion(workspace: string, project: string, version: number | "latest"): Promise<MemoryVersion>;
+    findMissingBlobs(workspace: string, project: string, hashes: string[]): Promise<{
+        missing: string[];
+    }>;
+    uploadBlobs(workspace: string, project: string, blobs: {
+        sha256: string;
+        content: string;
+    }[]): Promise<{
+        stored: string[];
+        refused: BlobRefusal[];
+    }>;
+    readBlobs(workspace: string, project: string, hashes: string[]): Promise<{
+        blobs: {
+            sha256: string;
+            content: string;
+        }[];
+        remaining: string[];
+    }>;
+    listValueAnswers(workspace: string): Promise<{
+        answers: ValueAnswerListed[];
+    }>;
+    lookupValues(workspace: string, values: FoundValue[]): Promise<{
+        answers: ValueAnswer[];
+    }>;
+    answerValues(workspace: string, answers: (FoundValue & {
+        answer: "ours" | "member";
+        label?: string;
+    })[]): Promise<ValueAnswerResults>;
+    fileMemoryPeople(workspace: string, people: {
+        values: FoundValue[];
+        label: string;
+    }[]): Promise<ValueAnswerResults>;
+    resolvePerson(workspace: string, personId: string): Promise<Person>;
     invalidateCache(path?: string): void;
     private buildUrl;
     private fetchRaw;

package/dist/lib/api-client.js

@@ -31,6 +31,28 @@ var ResponseCache = class {
 };
 
 // src/lib/api-client.ts
+var SystemDoxApiError = class extends Error {
+  constructor(status, text) {
+    super(`SystemDox API error ${status}: ${text}`);
+    this.status = status;
+    this.text = text;
+    let body;
+    try {
+      body = JSON.parse(text);
+    } catch {
+      body = void 0;
+    }
+    this.body = body;
+    const code = body?.code;
+    this.code = typeof code === "string" ? code : /\b(SYD-[A-Z]\d{3})\b/.exec(text)?.[1];
+  }
+  status;
+  text;
+  code;
+  body;
+};
+var TEAM_SETUP = "/v1/team-setup";
+var seg = (s) => encodeURIComponent(String(s));
 var SystemDoxApiClient = class {
   config;
   cache;
@@ -52,10 +74,7 @@ var SystemDoxApiClient = class {
     const cached = this.cache.get(cacheKey);
     if (cached !== void 0) return cached;
     const res = await this.fetchRaw(path, params);
-    if (!res.ok) {
-      const body = await res.text();
-      throw new Error(`SystemDox API error ${res.status}: ${body}`);
-    }
+    if (!res.ok) throw new SystemDoxApiError(res.status, await res.text());
     const data = await res.json();
     this.cache.set(cacheKey, data);
     return data;
@@ -64,10 +83,7 @@ var SystemDoxApiClient = class {
    * latest now, not the one cached before someone published another. */
   async getFresh(path) {
     const res = await this.fetchRaw(path);
-    if (!res.ok) {
-      const body = await res.text();
-      throw new Error(`SystemDox API error ${res.status}: ${body}`);
-    }
+    if (!res.ok) throw new SystemDoxApiError(res.status, await res.text());
     return await res.json();
   }
   async post(path, body) {
@@ -89,12 +105,101 @@ var SystemDoxApiClient = class {
       },
       body: JSON.stringify(body)
     });
-    if (!res.ok) {
-      const text = await res.text();
-      throw new Error(`SystemDox API error ${res.status}: ${text}`);
-    }
+    if (!res.ok) throw new SystemDoxApiError(res.status, await res.text());
     return await res.json();
   }
+  // ── Team setup (ADR-217, specs/changes/team-setup/openapi.yaml) ──────────
+  // One method per operationId. Every read skips the cache: setup, sync and
+  // plugin-path act on what the workspace holds now.
+  /** getOwnTeamSetup: the key's own workspace, named in `workspace`. */
+  getOwnTeamSetup() {
+    return this.getFresh(TEAM_SETUP);
+  }
+  getTeamSetup(workspace) {
+    return this.getFresh(`${TEAM_SETUP}/${seg(workspace)}`);
+  }
+  getMarketplace(workspace) {
+    return this.getFresh(`${TEAM_SETUP}/${seg(workspace)}/marketplace.json`);
+  }
+  getPart(workspace, part) {
+    return this.getFresh(`${TEAM_SETUP}/${seg(workspace)}/parts/${seg(part)}`);
+  }
+  publishPartVersion(workspace, part, files) {
+    return this.post(`${TEAM_SETUP}/${seg(workspace)}/parts/${seg(part)}/versions`, { files });
+  }
+  getPartVersion(workspace, part, version) {
+    return this.getFresh(
+      `${TEAM_SETUP}/${seg(workspace)}/parts/${seg(part)}/versions/${seg(version)}`
+    );
+  }
+  getSetupSkills(workspace) {
+    return this.getFresh(`${TEAM_SETUP}/${seg(workspace)}/skills`);
+  }
+  setSetupSkills(workspace, skills) {
+    return this.put(`${TEAM_SETUP}/${seg(workspace)}/skills`, { skills });
+  }
+  getPlugin(workspace) {
+    return this.getFresh(`${TEAM_SETUP}/${seg(workspace)}/plugin`);
+  }
+  /** getPluginZip: the zip's bytes as served, and its X-Content-SHA256
+   * header. The caller checks the BYTES against the hash it was given. */
+  async getPluginZip(workspace, version) {
+    const res = await fetch(
+      this.buildUrl(`${TEAM_SETUP}/${seg(workspace)}/plugin/versions/${seg(version)}/zip`),
+      {
+        headers: {
+          Authorization: `Bearer ${this.config.apiKey}`,
+          "X-API-Key": this.config.apiKey,
+          Accept: "application/zip"
+        }
+      }
+    );
+    if (!res.ok) throw new SystemDoxApiError(res.status, await res.text());
+    return { bytes: Buffer.from(await res.arrayBuffer()), sha256: res.headers.get("x-content-sha256") };
+  }
+  listMemoryProjects(workspace) {
+    return this.getFresh(`${TEAM_SETUP}/${seg(workspace)}/memory`);
+  }
+  getMemory(workspace, project) {
+    return this.getFresh(`${TEAM_SETUP}/${seg(workspace)}/memory/${seg(project)}`);
+  }
+  /** pushMemoryVersion: a stale base throws SystemDoxApiError with status 409,
+   * code SYD-K010 and `body.currentVersion`. */
+  pushMemoryVersion(workspace, project, body) {
+    return this.post(`${TEAM_SETUP}/${seg(workspace)}/memory/${seg(project)}/versions`, body);
+  }
+  getMemoryVersion(workspace, project, version) {
+    return this.getFresh(
+      `${TEAM_SETUP}/${seg(workspace)}/memory/${seg(project)}/versions/${seg(version)}`
+    );
+  }
+  findMissingBlobs(workspace, project, hashes) {
+    return this.post(
+      `${TEAM_SETUP}/${seg(workspace)}/memory/${seg(project)}/blobs/missing`,
+      { hashes }
+    );
+  }
+  uploadBlobs(workspace, project, blobs) {
+    return this.post(`${TEAM_SETUP}/${seg(workspace)}/memory/${seg(project)}/blobs`, { blobs });
+  }
+  readBlobs(workspace, project, hashes) {
+    return this.post(`${TEAM_SETUP}/${seg(workspace)}/memory/${seg(project)}/blobs/read`, { hashes });
+  }
+  listValueAnswers(workspace) {
+    return this.getFresh(`${TEAM_SETUP}/${seg(workspace)}/values`);
+  }
+  lookupValues(workspace, values) {
+    return this.post(`${TEAM_SETUP}/${seg(workspace)}/values`, { values });
+  }
+  answerValues(workspace, answers) {
+    return this.put(`${TEAM_SETUP}/${seg(workspace)}/values`, { answers });
+  }
+  fileMemoryPeople(workspace, people) {
+    return this.post(`${TEAM_SETUP}/${seg(workspace)}/people`, { people });
+  }
+  resolvePerson(workspace, personId) {
+    return this.getFresh(`${TEAM_SETUP}/${seg(workspace)}/people/${seg(personId)}`);
+  }
   invalidateCache(path) {
     if (path) {
       this.cache.invalidate(this.buildUrl(path).toString());
@@ -124,5 +229,6 @@ var SystemDoxApiClient = class {
   }
 };
 export {
-  SystemDoxApiClient
+  SystemDoxApiClient,
+  SystemDoxApiError
 };

package/dist/lib/memory-sync.d.ts

@@ -0,0 +1,150 @@
+/**
+ * The team memory's merge (ADR-217 §2.3, specs/changes/team-setup/contract.md
+ * "sync-memory and the MCP tool sync_memory"), pure: no disk, no network.
+ * `src/sync-memory.ts` reads the folders and calls the API around it.
+ *
+ * - **What is shared** (`isShareable`): a `*.md` file whose frontmatter `type`
+ *   is `feedback`, `project` or `reference`, and `MEMORY.md`; never a file
+ *   with `share: false` or a `<name>.local-<date>.md` conflict copy.
+ * - **The merge** (`decide`, `planMerge`): three-way per path, with the base
+ *   (the manifest of the last sync), the team's latest version and the local
+ *   folder, row by row as the contract's table says.
+ * - **`MEMORY.md`** (`mergeIndex`): line by line, keyed by the file each line
+ *   links to; never a `.local-` copy.
+ * - **People** (`collectValues`, `rewriteValues`, `personToken`): every value
+ *   the detector finds, grouped by its normalised form, and the rewrite the
+ *   member agrees to.
+ */
+import { type Finding, type ValueKind } from "./person-values.js";
+export declare const INDEX_FILE = "MEMORY.md";
+export declare const SHAREABLE_TYPES: readonly ["feedback", "project", "reference"];
+/** `{path: sha256}` (openapi Manifest). */
+export type Manifest = Record<string, string>;
+export declare function sha256(text: string): string;
+export declare function isFilePath(path: string): boolean;
+export declare function isConflictCopy(path: string): boolean;
+export interface Frontmatter {
+    type?: string;
+    /** True when the block says `share: false` (or another YAML false). */
+    shareFalse: boolean;
+}
+/** The frontmatter's `type` and `share`, or undefined when the file has no
+ * leading block. Only top-level `key: value` lines are read. */
+export declare function readFrontmatter(text: string): Frontmatter | undefined;
+/**
+ * Shared with the team: `MEMORY.md` at the folder's root, or a `*.md` file
+ * whose frontmatter `type` is feedback, project or reference. Never a file
+ * with `share: false`, a `.local-` conflict copy, or anything else.
+ */
+export declare function isShareable(path: string, text: string): boolean;
+/** `text` with `share: false` in its frontmatter: the line is added before the
+ * block's closing `---` (or replaces a `share:` line), or a block is added. */
+export declare function addShareFalse(text: string): string;
+/** The member's calendar date, `YYYY-MM-DD`. */
+export declare function localDate(now: Date): string;
+/** `a.md` → `a.local-<date>.md`, then `a.local-<date>-2.md`, `-3` … when the
+ * name is taken. */
+export declare function conflictCopyName(path: string, date: string, taken: Set<string>): string;
+/**
+ * One path's row of the contract's table (base → team, base → local):
+ * - `unchanged`: both sides hold the same (or neither holds it);
+ * - `local`: the team did not change it and the member changed or added it;
+ *   also a file the team deleted and the member changed (the member's text
+ *   is kept, never lost);
+ * - `delete-team`: the team did not change it and the member deleted it;
+ * - `team`: the member did not change it and the team changed or added it;
+ *   also a file the member deleted and the team changed (the team's text
+ *   comes back, never lost);
+ * - `delete-local`: the member did not change it and the team deleted it;
+ * - `conflict`: both changed it differently;
+ * - `index`: `MEMORY.md` changed on both sides, merged line by line.
+ */
+export type Row = "unchanged" | "local" | "delete-team" | "team" | "delete-local" | "conflict" | "index";
+export declare function decide(path: string, base: string | undefined, team: string | undefined, local: string | undefined): Row;
+export interface MergeInput {
+    base: Manifest;
+    team: Manifest;
+    /** The local folder's shared files, `{path: text}`. */
+    local: Record<string, string>;
+    /** Paths left as they are on both sides: a file held back this run, or a
+     * local file that is not shared. The team's entry is kept; nothing is
+     * written to the path. */
+    excluded: Set<string>;
+    /** Every file name in the folder (lower case), so a conflict copy never
+     * takes a name in use. */
+    taken: Set<string>;
+    date: string;
+}
+/** The rows by path, and the team hashes whose text the plan needs. */
+export declare function decideAll(input: Omit<MergeInput, "taken" | "date">): {
+    rows: Record<string, Row>;
+    needed: string[];
+};
+export interface MergePlan {
+    /** The manifest to push. */
+    manifest: Manifest;
+    /** The text of each path whose hash the team does not hold yet. */
+    upload: Record<string, string>;
+    /** Files to write in the local folder (pulled, conflict pairs, the index). */
+    writes: Record<string, string>;
+    /** Files to delete in the local folder. */
+    deletes: string[];
+    pulled: string[];
+    pushed: string[];
+    deletedHere: string[];
+    deletedFromTeam: string[];
+    conflicts: {
+        path: string;
+        copy: string;
+    }[];
+    /** `MEMORY.md` lines the team changed where the member's line was kept. */
+    indexTeamLines: string[];
+}
+/** The plan for the rows of `decideAll`, given the text of every hash it
+ * named (`texts`, `{sha256: text}`). A base `MEMORY.md` no longer readable is
+ * merged as if empty. */
+export declare function planMerge(input: MergeInput, rows: Record<string, Row>, texts: Record<string, string>): MergePlan;
+/**
+ * `MEMORY.md` merged line by line, keyed by the file each line links to
+ * (ADR-217 §2.3.3):
+ * - a team line for a new file is added under the same heading (after the
+ *   line it follows in the team's copy);
+ * - a line the team removed and the member did not change is removed;
+ * - a line with no link takes the team's text unless the member changed it;
+ * - when both changed the same line, the member's line is kept and the
+ *   team's is returned in `teamLines`, to be listed.
+ */
+export declare function mergeIndex(base: string | undefined, team: string, local: string): {
+    text: string;
+    teamLines: string[];
+};
+export interface ValueGroup {
+    kind: ValueKind;
+    /** As first written. */
+    value: string;
+    normalised: string;
+    files: string[];
+    /** Where it first appears: the file, the line number and the line. */
+    first: {
+        path: string;
+        line: number;
+        text: string;
+    };
+}
+export declare const groupKey: (kind: string, normalised: string) => string;
+/** Every phone number and email address in `files`, grouped by normalised
+ * value in the order first found; and the files holding a home-folder path. */
+export declare function collectValues(files: Record<string, string>): {
+    groups: ValueGroup[];
+    homePaths: string[];
+    findings: Record<string, Finding[]>;
+};
+/** `` `<personId>` (<label>) ``: the identifier exactly as the server
+ * returned it, and the role label when there is one. */
+export declare function personToken(personId: string, label?: string): string;
+/** `text` with each finding replaced as `replacement` says (undefined leaves
+ * it as written). */
+export declare function rewriteValues(text: string, findings: Finding[], replacement: (f: Finding) => string | undefined): string;
+/** The lines that differ between two versions of a file, as `- old` and
+ * `+ new` pairs, in order. */
+export declare function lineDiff(before: string, after: string): string[];