@smwb/onreel-git-mcp 0.0.0-stage → 0.2.0

package/dist/contract/contract.schema.d.ts

@@ -0,0 +1,279 @@
+import { z } from 'zod';
+/** Идентификатор сущности: Run, Task, Dispatch, письма, gate, сессии и т. п. */
+export declare const entityIdSchema: z.ZodString;
+/** Ключ идемпотентности запроса: его создаёт клиент, повтор с тем же ключом возвращает receipt. */
+export declare const requestIdSchema: z.ZodString;
+export declare const projectIdSchema: z.ZodString;
+export declare const taskIdSchema: z.ZodString;
+/** Время — миллисекунды Unix epoch, как INTEGER в хранилище. */
+export declare const timestampSchema: z.ZodNumber;
+export declare const contractVersionSchema: z.ZodObject<{
+    major: z.ZodNumber;
+    minor: z.ZodNumber;
+}, z.core.$strip>;
+export declare const errorCodeSchema: z.ZodEnum<{
+    agent_unavailable: "agent_unavailable";
+    agent_untrusted: "agent_untrusted";
+    budget_exceeded: "budget_exceeded";
+    capability_unsupported: "capability_unsupported";
+    claim_conflict: "claim_conflict";
+    claim_limit: "claim_limit";
+    consumer_fenced: "consumer_fenced";
+    contract_incompatible: "contract_incompatible";
+    git_failed: "git_failed";
+    host_not_live: "host_not_live";
+    inactive_dispatch: "inactive_dispatch";
+    internal: "internal";
+    invalid_request: "invalid_request";
+    lease_conflict: "lease_conflict";
+    lease_expired: "lease_expired";
+    lease_fenced: "lease_fenced";
+    lifecycle_conflict: "lifecycle_conflict";
+    member_name_taken: "member_name_taken";
+    messaging_denied: "messaging_denied";
+    not_assignee: "not_assignee";
+    not_found: "not_found";
+    ownership_conflict: "ownership_conflict";
+    permission_denied: "permission_denied";
+    plan_required: "plan_required";
+    project_exists: "project_exists";
+    rate_limited: "rate_limited";
+    request_id_reused: "request_id_reused";
+    sandbox_unavailable: "sandbox_unavailable";
+    session_exited: "session_exited";
+    spawn_failed: "spawn_failed";
+    stale_dispatch: "stale_dispatch";
+    task_dispatch_mismatch: "task_dispatch_mismatch";
+    tracker_failed: "tracker_failed";
+    unauthorized: "unauthorized";
+    unavailable: "unavailable";
+    unknown_dispatch: "unknown_dispatch";
+    unknown_issue: "unknown_issue";
+    unknown_project: "unknown_project";
+    unknown_session: "unknown_session";
+    unknown_task: "unknown_task";
+}>;
+/** Код на проводе: известный код каталога или код более новой версии контракта. */
+export declare const wireErrorCodeSchema: z.ZodString;
+export declare const contractErrorSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    nextSteps: z.ZodArray<z.ZodString>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/** Вид трекера — открытый слаг: новый трекер добавляется подключением на host без правки контракта. */
+export declare const trackerKindSchema: z.ZodString;
+/** Ключ задачи в своём трекере: `76`, `PROJ-12`, `#5`; для клиента непрозрачная строка. */
+export declare const issueKeySchema: z.ZodString;
+/** Категория статуса единой модели; своё имя статуса трекер отдаёт отдельно, в `status.name`. */
+export declare const issueStatusCategorySchema: z.ZodEnum<{
+    declined: "declined";
+    done: "done";
+    in_progress: "in_progress";
+    open: "open";
+}>;
+/** Приоритет единой модели; трекер без приоритетов не заполняет поле. */
+export declare const issuePrioritySchema: z.ZodEnum<{
+    blocker: "blocker";
+    critical: "critical";
+    minor: "minor";
+    normal: "normal";
+    trivial: "trivial";
+}>;
+export declare const issueLinkSchema: z.ZodObject<{
+    url: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const issueSchema: z.ZodObject<{
+    key: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    status: z.ZodObject<{
+        category: z.ZodEnum<{
+            declined: "declined";
+            done: "done";
+            in_progress: "in_progress";
+            open: "open";
+        }>;
+        name: z.ZodString;
+    }, z.core.$strip>;
+    priority: z.ZodOptional<z.ZodEnum<{
+        blocker: "blocker";
+        critical: "critical";
+        minor: "minor";
+        normal: "normal";
+        trivial: "trivial";
+    }>>;
+    labels: z.ZodArray<z.ZodString>;
+    assignee: z.ZodOptional<z.ZodString>;
+    links: z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    createdAt: z.ZodOptional<z.ZodNumber>;
+    updatedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const issueCommentSchema: z.ZodObject<{
+    id: z.ZodString;
+    author: z.ZodOptional<z.ZodString>;
+    body: z.ZodString;
+    createdAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/** Поля подключения, которые descriptor может запросить у пользователя. */
+export declare const trackerFieldNameSchema: z.ZodEnum<{
+    target: "target";
+    token: "token";
+    url: "url";
+    user: "user";
+}>;
+/** Что трекер умеет: клиент прячет недоступные действия, а host отказывает в них `invalid_request`. */
+export declare const trackerFeaturesSchema: z.ZodObject<{
+    create: z.ZodBoolean;
+    update: z.ZodBoolean;
+    comment: z.ZodBoolean;
+    priority: z.ZodBoolean;
+    labels: z.ZodBoolean;
+    assignee: z.ZodBoolean;
+    statuses: z.ZodArray<z.ZodEnum<{
+        declined: "declined";
+        done: "done";
+        in_progress: "in_progress";
+        open: "open";
+    }>>;
+}, z.core.$strip>;
+export declare const trackerDescriptorSchema: z.ZodObject<{
+    tracker: z.ZodString;
+    title: z.ZodString;
+    fields: z.ZodArray<z.ZodObject<{
+        name: z.ZodEnum<{
+            target: "target";
+            token: "token";
+            url: "url";
+            user: "user";
+        }>;
+        required: z.ZodBoolean;
+        secret: z.ZodBoolean;
+    }, z.core.$strip>>;
+    features: z.ZodObject<{
+        create: z.ZodBoolean;
+        update: z.ZodBoolean;
+        comment: z.ZodBoolean;
+        priority: z.ZodBoolean;
+        labels: z.ZodBoolean;
+        assignee: z.ZodBoolean;
+        statuses: z.ZodArray<z.ZodEnum<{
+            declined: "declined";
+            done: "done";
+            in_progress: "in_progress";
+            open: "open";
+        }>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** Идентификатор Worktree: `wt-<uuid>`, как другие entityId контракта. */
+export declare const worktreeIdSchema: z.ZodString;
+/**
+ * Имя worktree проекта без задачи (onreel D-345): часть каталога `<repo>/_project/<name>` и ветки
+ * `onreel/_project/<name>`, поэтому только строчные латинские буквы, цифры и `-`; уникально среди
+ * неочищенных worktree проекта.
+ */
+export declare const worktreeNameSchema: z.ZodString;
+/** Коммит git: 40 hex (SHA-1) или 64 hex (SHA-256 репозитории). */
+export declare const gitShaSchema: z.ZodString;
+/** Состояние Worktree (onreel D-050): preparing — receipt принят, git ещё создаёт; ready — рабочий;
+ *  cleaning — очистка принята, диск ещё освобождается; cleaned — очищен (терминальное);
+ *  failed — создание или очистка не справились, причина в error, ждёт решения (worktree.remove). */
+export declare const worktreeStatusSchema: z.ZodEnum<{
+    cleaned: "cleaned";
+    cleaning: "cleaning";
+    failed: "failed";
+    preparing: "preparing";
+    ready: "ready";
+}>;
+/** Запись Worktree в хранилище: привязка к Task или проекту плюс git-факты (ветка, база, пути, голова). */
+export declare const worktreeSchema: z.ZodObject<{
+    id: z.ZodString;
+    taskId: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    branch: z.ZodString;
+    baseRef: z.ZodString;
+    baseSha: z.ZodString;
+    repoPath: z.ZodString;
+    path: z.ZodString;
+    status: z.ZodEnum<{
+        cleaned: "cleaned";
+        cleaning: "cleaning";
+        failed: "failed";
+        preparing: "preparing";
+        ready: "ready";
+    }>;
+    headSha: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    cleanedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/** Одна строка `git status --porcelain=v1`: две колонки XY и путь. */
+export declare const worktreeStatusEntrySchema: z.ZodObject<{
+    path: z.ZodString;
+    index: z.ZodString;
+    worktree: z.ZodString;
+}, z.core.$strip>;
+/** Путь внутри worktree: posix, относительный, без «..», NUL, обратных слэшей и ведущего «/». */
+export declare const reviewPathSchema: z.ZodString;
+export declare const worktreeChangeStatusSchema: z.ZodEnum<{
+    added: "added";
+    conflicted: "conflicted";
+    copied: "copied";
+    deleted: "deleted";
+    modified: "modified";
+    renamed: "renamed";
+    type_changed: "type_changed";
+}>;
+export declare const worktreeChangeSchema: z.ZodObject<{
+    path: z.ZodString;
+    oldPath: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        added: "added";
+        conflicted: "conflicted";
+        copied: "copied";
+        deleted: "deleted";
+        modified: "modified";
+        renamed: "renamed";
+        type_changed: "type_changed";
+    }>;
+    untracked: z.ZodOptional<z.ZodBoolean>;
+    binary: z.ZodOptional<z.ZodBoolean>;
+    additions: z.ZodOptional<z.ZodNumber>;
+    deletions: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/** Одна сторона файла; текста нет при `binary` или `truncated`. */
+export declare const worktreeFileSideSchema: z.ZodObject<{
+    size: z.ZodNumber;
+    binary: z.ZodBoolean;
+    truncated: z.ZodBoolean;
+    text: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Путь worktree.files — каталога запроса и записи ответа: путь ревью (D-320) без компоненты `.git` в любом
+ * регистре и без компоненты «.». У каждой записи одно написание пути: `./a` и `a` — не два файла.
+ */
+export declare const worktreeDirPathSchema: z.ZodString;
+/** Вид записи: `dir` раскрывается, `file` и `symlink` открываются просмотром, `other` (fifo, сокет, устройство) — нет. */
+export declare const worktreeEntryKindSchema: z.ZodEnum<{
+    dir: "dir";
+    file: "file";
+    other: "other";
+    symlink: "symlink";
+}>;
+export declare const worktreeEntrySchema: z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+    kind: z.ZodEnum<{
+        dir: "dir";
+        file: "file";
+        other: "other";
+        symlink: "symlink";
+    }>;
+    size: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;

package/dist/contract/contract.types.d.ts

@@ -0,0 +1,23 @@
+import type { z } from 'zod';
+import type { contractErrorSchema, contractVersionSchema, entityIdSchema, issueCommentSchema, issueLinkSchema, issuePrioritySchema, issueSchema, issueStatusCategorySchema, requestIdSchema, timestampSchema, trackerDescriptorSchema, trackerFeaturesSchema, trackerKindSchema, worktreeChangeSchema, worktreeChangeStatusSchema, worktreeEntryKindSchema, worktreeEntrySchema, worktreeFileSideSchema, worktreeSchema, worktreeStatusEntrySchema, worktreeStatusSchema } from './contract.schema.ts';
+export type EntityId = z.infer<typeof entityIdSchema>;
+export type RequestId = z.infer<typeof requestIdSchema>;
+export type Timestamp = z.infer<typeof timestampSchema>;
+export type ContractVersion = z.infer<typeof contractVersionSchema>;
+export type ContractError = z.infer<typeof contractErrorSchema>;
+export type TrackerKind = z.infer<typeof trackerKindSchema>;
+export type IssueStatusCategory = z.infer<typeof issueStatusCategorySchema>;
+export type IssuePriority = z.infer<typeof issuePrioritySchema>;
+export type IssueLink = z.infer<typeof issueLinkSchema>;
+export type Issue = z.infer<typeof issueSchema>;
+export type IssueComment = z.infer<typeof issueCommentSchema>;
+export type TrackerFeatures = z.infer<typeof trackerFeaturesSchema>;
+export type TrackerDescriptor = z.infer<typeof trackerDescriptorSchema>;
+export type Worktree = z.infer<typeof worktreeSchema>;
+export type WorktreeStatus = z.infer<typeof worktreeStatusSchema>;
+export type WorktreeStatusEntry = z.infer<typeof worktreeStatusEntrySchema>;
+export type WorktreeChange = z.infer<typeof worktreeChangeSchema>;
+export type WorktreeChangeStatus = z.infer<typeof worktreeChangeStatusSchema>;
+export type WorktreeFileSide = z.infer<typeof worktreeFileSideSchema>;
+export type WorktreeEntryKind = z.infer<typeof worktreeEntryKindSchema>;
+export type WorktreeEntry = z.infer<typeof worktreeEntrySchema>;

package/dist/files/files.const.d.ts

@@ -0,0 +1,6 @@
+/** Сколько записей каталога host просматривает за вызов worktree.files (D-367). */
+export declare const WORKTREE_FILES_SCAN_MAX = 10000;
+/** Сколько битых симлинков подряд host проходит, выясняя, не ведёт ли путь за worktree: столько же, сколько ядро до ELOOP. */
+export declare const WORKTREE_FILES_LINK_HOPS = 40;
+/** Служебный каталог git: не показывается ни на каком уровне, без учёта регистра. */
+export declare const GIT_ENTRY_NAME = ".git";

package/dist/files/files.lib.d.ts

@@ -0,0 +1,14 @@
+import type { DirListing, DirListLimits, DirRefusalReason } from './files.types.ts';
+/** Отказ чтения каталога; controller переводит причину в ошибку контракта по матрице D-367. */
+export declare class DirRefusal extends Error {
+    readonly reason: DirRefusalReason;
+    constructor(reason: DirRefusalReason, message: string);
+}
+/**
+ * Записи каталога `path` worktree (без `path` — корня). Каталог worktree проверяется как перед очисткой
+ * (checkManagedPath), realpath каталога обязан лежать в realpath worktree и не внутри `.git`. Записи `.git` без
+ * учёта регистра пропускаются; вид берётся из dirent (семантика lstat), поэтому симлинк остаётся листом.
+ * Просматривается не больше `scanMax` записей; имя не в UTF-8 или запись, не прошедшая схему, пропускается с
+ * `truncated`, как и всё сверх `maxEntries` после сортировки.
+ */
+export declare function listWorktreeDir(dataDir: string, worktreePath: string, path: string | undefined, limits?: DirListLimits): Promise<DirListing>;

package/dist/files/files.types.d.ts

@@ -0,0 +1,13 @@
+import type { WorktreeFilesReason } from '../contract/contract.const.ts';
+import type { WorktreeEntry } from '../contract/contract.types.ts';
+/** Пределы одного вызова: записей в ответе и просмотренных записей каталога. */
+export type DirListLimits = {
+    maxEntries: number;
+    scanMax: number;
+};
+/** Причина отказа чтения каталога: `not_found` — каталога нет, остальное — `data.reason` контракта. */
+export type DirRefusalReason = 'not_found' | WorktreeFilesReason;
+export type DirListing = {
+    entries: WorktreeEntry[];
+    truncated: boolean;
+};

package/dist/files/index.d.ts

@@ -0,0 +1,3 @@
+export * from './files.const.ts';
+export * from './files.types.ts';
+export * from './files.lib.ts';

package/dist/files/index.js

@@ -0,0 +1,163 @@
+import {
+  PathEscapeError,
+  checkManagedPath,
+  isInside
+} from "../chunk-C6PHNSDC.js";
+import {
+  WORKTREE_FILES_MAX,
+  worktreeEntrySchema
+} from "../chunk-4ZGRXIVA.js";
+
+// src/files/files.const.ts
+var WORKTREE_FILES_SCAN_MAX = 1e4;
+var WORKTREE_FILES_LINK_HOPS = 40;
+var GIT_ENTRY_NAME = ".git";
+
+// src/files/files.lib.ts
+import { lstat, opendir, readlink, realpath } from "fs/promises";
+import { dirname, join, relative, resolve, sep } from "path";
+var DirRefusal = class extends Error {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.name = "DirRefusal";
+    this.reason = reason;
+  }
+};
+async function listWorktreeDir(dataDir, worktreePath, path, limits = { maxEntries: WORKTREE_FILES_MAX, scanMax: WORKTREE_FILES_SCAN_MAX }) {
+  const root = await worktreeRoot(dataDir, worktreePath);
+  const target = path === void 0 ? root : resolve(root, path);
+  if (target !== root && !isInside(root, target)) throw new DirRefusal("outside_worktree", `\u043F\u0443\u0442\u044C '${String(path)}' \u0432\u044B\u0445\u043E\u0434\u0438\u0442 \u0437\u0430 worktree`);
+  const real = target === root ? root : await realTarget(root, target, path);
+  if (real !== root && !isInside(root, real)) throw new DirRefusal("outside_worktree", `realpath \u043F\u0443\u0442\u0438 '${String(path)}' \u0432\u044B\u0445\u043E\u0434\u0438\u0442 \u0437\u0430 worktree`);
+  if (relative(root, real).split(sep).some(isGitName)) throw new DirRefusal("excluded", `\u043F\u0443\u0442\u044C '${String(path)}' \u0432\u0435\u0434\u0451\u0442 \u0432 \u043A\u0430\u0442\u0430\u043B\u043E\u0433 .git`);
+  const info = await fsStep(() => lstat(real));
+  if (!info.isDirectory()) throw new DirRefusal("not_directory", `\u043F\u0443\u0442\u044C '${String(path)}' \u2014 \u043D\u0435 \u043A\u0430\u0442\u0430\u043B\u043E\u0433`);
+  let truncated = false;
+  let scanned = 0;
+  const found = [];
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  const dir = await fsStep(() => opendir(real, { encoding: "buffer" }));
+  for await (const dirent of dir) {
+    if (scanned >= limits.scanMax) {
+      truncated = true;
+      break;
+    }
+    scanned += 1;
+    const name = decodeName(dirent.name, decoder);
+    if (name === void 0) {
+      truncated = true;
+      continue;
+    }
+    if (isGitName(name)) continue;
+    const entry = worktreeEntrySchema.safeParse({ name, path: path === void 0 ? name : `${path}/${name}`, kind: kindOf(dirent) });
+    if (!entry.success) {
+      truncated = true;
+      continue;
+    }
+    found.push(entry.data);
+  }
+  found.sort(byKindAndName);
+  if (found.length > limits.maxEntries) truncated = true;
+  const entries = await Promise.all(found.slice(0, limits.maxEntries).map((entry) => entry.kind === "file" ? withSize(real, entry) : Promise.resolve(entry)));
+  return { entries, truncated };
+}
+async function worktreeRoot(dataDir, worktreePath) {
+  let present;
+  try {
+    present = checkManagedPath(dataDir, worktreePath);
+  } catch (error) {
+    if (error instanceof PathEscapeError) throw new DirRefusal("unsafe_path", error.message);
+    throw error;
+  }
+  if (!present) throw new DirRefusal("missing_on_disk", `\u043A\u0430\u0442\u0430\u043B\u043E\u0433\u0430 worktree ${worktreePath} \u043D\u0435\u0442 \u043D\u0430 \u0434\u0438\u0441\u043A\u0435`);
+  try {
+    return await realpath(worktreePath);
+  } catch (error) {
+    if (fsCode(error) === "ENOENT") throw new DirRefusal("missing_on_disk", `\u043A\u0430\u0442\u0430\u043B\u043E\u0433\u0430 worktree ${worktreePath} \u043D\u0435\u0442 \u043D\u0430 \u0434\u0438\u0441\u043A\u0435`);
+    throw error;
+  }
+}
+async function realTarget(root, target, path) {
+  try {
+    return await realpath(target);
+  } catch (error) {
+    const refusal = fsRefusal(error);
+    if (refusal === void 0) throw error;
+    if (await leadsOutside(root, target)) throw new DirRefusal("outside_worktree", `\u043F\u0443\u0442\u044C '${String(path)}' \u0432\u044B\u0445\u043E\u0434\u0438\u0442 \u0437\u0430 worktree`);
+    throw refusal;
+  }
+}
+async function leadsOutside(root, start) {
+  let current = start;
+  for (let hops = 0; current !== root; ) {
+    if (!isInside(root, current)) return true;
+    const real = await realpath(current).catch(() => void 0);
+    if (real !== void 0) return real !== root && !isInside(root, real);
+    const link = hops < WORKTREE_FILES_LINK_HOPS ? await readlink(current).catch(() => void 0) : void 0;
+    if (link === void 0) {
+      current = dirname(current);
+      continue;
+    }
+    hops += 1;
+    const base = await realpath(dirname(current)).catch(() => dirname(current));
+    current = resolve(base, link);
+  }
+  return false;
+}
+async function fsStep(step) {
+  try {
+    return await step();
+  } catch (error) {
+    throw fsRefusal(error) ?? error;
+  }
+}
+function fsRefusal(error) {
+  const code = fsCode(error);
+  if (code === "ENOENT" || code === "ENOTDIR" || code === "ELOOP" || code === "ENAMETOOLONG") return new DirRefusal("not_found", messageOf(error));
+  if (code === "EACCES" || code === "EPERM") return new DirRefusal("unreadable", messageOf(error));
+  return void 0;
+}
+function fsCode(error) {
+  return error?.code;
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isGitName(name) {
+  return name.toLowerCase() === GIT_ENTRY_NAME;
+}
+function decodeName(raw, decoder) {
+  if (typeof raw === "string") return raw;
+  try {
+    return decoder.decode(raw);
+  } catch {
+    return void 0;
+  }
+}
+function kindOf(dirent) {
+  if (dirent.isDirectory()) return "dir";
+  if (dirent.isFile()) return "file";
+  if (dirent.isSymbolicLink()) return "symlink";
+  return "other";
+}
+function byKindAndName(a, b) {
+  const rank = Number(a.kind !== "dir") - Number(b.kind !== "dir");
+  if (rank !== 0) return rank;
+  return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+}
+async function withSize(dir, entry) {
+  try {
+    return { ...entry, size: (await lstat(join(dir, entry.name))).size };
+  } catch {
+    return entry;
+  }
+}
+export {
+  DirRefusal,
+  GIT_ENTRY_NAME,
+  WORKTREE_FILES_LINK_HOPS,
+  WORKTREE_FILES_SCAN_MAX,
+  listWorktreeDir
+};
+//# sourceMappingURL=index.js.map

package/dist/files/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/files/files.const.ts","../../src/files/files.lib.ts"],"sourcesContent":["// Происхождение — onreel @ b73407be076a5df73931d1340f70910ca13c908d,\n// src/host/worktree/files.const.ts — дословная копия.\n\n// Пределы и исключения списка файлов worktree (#64, D-367).\n\n/** Сколько записей каталога host просматривает за вызов worktree.files (D-367). */\nexport const WORKTREE_FILES_SCAN_MAX = 10_000;\n\n/** Сколько битых симлинков подряд host проходит, выясняя, не ведёт ли путь за worktree: столько же, сколько ядро до ELOOP. */\nexport const WORKTREE_FILES_LINK_HOPS = 40;\n\n/** Служебный каталог git: не показывается ни на каком уровне, без учёта регистра. */\nexport const GIT_ENTRY_NAME = '.git';\n","// Происхождение — onreel @ b73407be076a5df73931d1340f70910ca13c908d,\n// src/host/worktree/files.lib.ts — дословная копия; импорт констант, схем и типов контракта\n// перенацелен на срез src/contract этой библиотеки (часть B выделения).\n\nimport type { OpenDirOptions } from 'node:fs';\nimport { lstat, opendir, readlink, realpath } from 'node:fs/promises';\nimport { dirname, join, relative, resolve, sep } from 'node:path';\nimport { WORKTREE_FILES_MAX } from '../contract/contract.const.ts';\nimport { worktreeEntrySchema } from '../contract/contract.schema.ts';\nimport type { WorktreeEntry, WorktreeEntryKind } from '../contract/contract.types.ts';\nimport { GIT_ENTRY_NAME, WORKTREE_FILES_LINK_HOPS, WORKTREE_FILES_SCAN_MAX } from './files.const.ts';\nimport type { DirListing, DirListLimits, DirRefusalReason } from './files.types.ts';\nimport { checkManagedPath, isInside, PathEscapeError } from '../git/paths.lib.ts';\n\n// Список файлов worktree (#64, D-367): записи одного каталога без `.git` в пределах realpath worktree; симлинки не разыменовываются, глубже одного каталога host не идёт.\n\n/** Отказ чтения каталога; controller переводит причину в ошибку контракта по матрице D-367. */\nexport class DirRefusal extends Error {\n  readonly reason: DirRefusalReason;\n\n  constructor(reason: DirRefusalReason, message: string) {\n    super(message);\n    this.name = 'DirRefusal';\n    this.reason = reason;\n  }\n}\n\n/**\n * Записи каталога `path` worktree (без `path` — корня). Каталог worktree проверяется как перед очисткой\n * (checkManagedPath), realpath каталога обязан лежать в realpath worktree и не внутри `.git`. Записи `.git` без\n * учёта регистра пропускаются; вид берётся из dirent (семантика lstat), поэтому симлинк остаётся листом.\n * Просматривается не больше `scanMax` записей; имя не в UTF-8 или запись, не прошедшая схему, пропускается с\n * `truncated`, как и всё сверх `maxEntries` после сортировки.\n */\nexport async function listWorktreeDir(\n  dataDir: string,\n  worktreePath: string,\n  path: string | undefined,\n  limits: DirListLimits = { maxEntries: WORKTREE_FILES_MAX, scanMax: WORKTREE_FILES_SCAN_MAX },\n): Promise<DirListing> {\n  const root = await worktreeRoot(dataDir, worktreePath);\n  const target = path === undefined ? root : resolve(root, path);\n  if (target !== root && !isInside(root, target)) throw new DirRefusal('outside_worktree', `путь '${String(path)}' выходит за worktree`);\n  const real = target === root ? root : await realTarget(root, target, path);\n  if (real !== root && !isInside(root, real)) throw new DirRefusal('outside_worktree', `realpath пути '${String(path)}' выходит за worktree`);\n  if (relative(root, real).split(sep).some(isGitName)) throw new DirRefusal('excluded', `путь '${String(path)}' ведёт в каталог .git`);\n  // real уже без симлинков: lstat видит сам каталог, а подменённый между шагами симлинк — не каталог.\n  const info = await fsStep(() => lstat(real));\n  if (!info.isDirectory()) throw new DirRefusal('not_directory', `путь '${String(path)}' — не каталог`);\n\n  let truncated = false;\n  let scanned = 0;\n  const found: WorktreeEntry[] = [];\n  const decoder = new TextDecoder('utf-8', { fatal: true });\n  // Имена — байтами: имя не в UTF-8 иначе пришло бы с U+FFFD и вело бы на другой путь. Типы @types/node\n  // не знают encoding 'buffer' у opendir, а Node его поддерживает.\n  const dir = await fsStep(() => opendir(real, { encoding: 'buffer' } as unknown as OpenDirOptions));\n  for await (const dirent of dir) {\n    if (scanned >= limits.scanMax) {\n      truncated = true;\n      break;\n    }\n    scanned += 1;\n    const name = decodeName(dirent.name as string | Buffer, decoder);\n    if (name === undefined) {\n      truncated = true;\n      continue;\n    }\n    if (isGitName(name)) continue;\n    const entry = worktreeEntrySchema.safeParse({ name, path: path === undefined ? name : `${path}/${name}`, kind: kindOf(dirent) });\n    if (!entry.success) {\n      truncated = true;\n      continue;\n    }\n    found.push(entry.data);\n  }\n\n  found.sort(byKindAndName);\n  if (found.length > limits.maxEntries) truncated = true;\n  const entries = await Promise.all(found.slice(0, limits.maxEntries).map((entry) => (entry.kind === 'file' ? withSize(real, entry) : Promise.resolve(entry))));\n  return { entries, truncated };\n}\n\n/** realpath каталога worktree после проверки, что он управляется host: нет на диске или подменён — отказ. */\nasync function worktreeRoot(dataDir: string, worktreePath: string): Promise<string> {\n  let present: boolean;\n  try {\n    present = checkManagedPath(dataDir, worktreePath);\n  } catch (error) {\n    if (error instanceof PathEscapeError) throw new DirRefusal('unsafe_path', error.message);\n    throw error;\n  }\n  if (!present) throw new DirRefusal('missing_on_disk', `каталога worktree ${worktreePath} нет на диске`);\n  try {\n    return await realpath(worktreePath);\n  } catch (error) {\n    if (fsCode(error) === 'ENOENT') throw new DirRefusal('missing_on_disk', `каталога worktree ${worktreePath} нет на диске`);\n    throw error;\n  }\n}\n\n/**\n * realpath каталога запроса. realpath не получился (пути нет, нет прав, битый симлинк), но путь ведёт за\n * worktree — outside_worktree, а не not_found или unreadable: путь за симлинком наружу отказывает одинаково,\n * что бы ни лежало снаружи.\n */\nasync function realTarget(root: string, target: string, path: string | undefined): Promise<string> {\n  try {\n    return await realpath(target);\n  } catch (error) {\n    const refusal = fsRefusal(error);\n    if (refusal === undefined) throw error;\n    if (await leadsOutside(root, target)) throw new DirRefusal('outside_worktree', `путь '${String(path)}' выходит за worktree`);\n    throw refusal;\n  }\n}\n\n/**\n * Ведёт ли путь без realpath за worktree. От пути к корню: ближайший предок с realpath решает сам; битый\n * симлинк по дороге заменяется своей целью (`dangling -> <снаружи>/нет`), и обход идёт уже от неё.\n */\nasync function leadsOutside(root: string, start: string): Promise<boolean> {\n  let current = start;\n  for (let hops = 0; current !== root; ) {\n    if (!isInside(root, current)) return true;\n    const real = await realpath(current).catch(() => undefined);\n    if (real !== undefined) return real !== root && !isInside(root, real);\n    const link = hops < WORKTREE_FILES_LINK_HOPS ? await readlink(current).catch(() => undefined) : undefined;\n    if (link === undefined) {\n      current = dirname(current);\n      continue;\n    }\n    hops += 1;\n    const base = await realpath(dirname(current)).catch(() => dirname(current));\n    current = resolve(base, link);\n  }\n  return false;\n}\n\n/** Шаг файловой системы над каталогом запроса; отказ — через fsRefusal, прочее — дальше. */\nasync function fsStep<T>(step: () => Promise<T>): Promise<T> {\n  try {\n    return await step();\n  } catch (error) {\n    throw fsRefusal(error) ?? error;\n  }\n}\n\n/** Ошибка файловой системы как отказ: нет пути — not_found, нет прав — unreadable; прочее — undefined (internal). */\nfunction fsRefusal(error: unknown): DirRefusal | undefined {\n  const code = fsCode(error);\n  // Петля симлинков и слишком длинная компонента тоже значат, что каталога по этому пути нет.\n  if (code === 'ENOENT' || code === 'ENOTDIR' || code === 'ELOOP' || code === 'ENAMETOOLONG') return new DirRefusal('not_found', messageOf(error));\n  if (code === 'EACCES' || code === 'EPERM') return new DirRefusal('unreadable', messageOf(error));\n  return undefined;\n}\n\nfunction fsCode(error: unknown): unknown {\n  return (error as { code?: unknown } | null)?.code;\n}\n\nfunction messageOf(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n\nfunction isGitName(name: string): boolean {\n  return name.toLowerCase() === GIT_ENTRY_NAME;\n}\n\nfunction decodeName(raw: string | Buffer, decoder: TextDecoder): string | undefined {\n  if (typeof raw === 'string') return raw;\n  try {\n    return decoder.decode(raw);\n  } catch {\n    return undefined;\n  }\n}\n\nfunction kindOf(dirent: { isDirectory(): boolean; isFile(): boolean; isSymbolicLink(): boolean }): WorktreeEntryKind {\n  if (dirent.isDirectory()) return 'dir';\n  if (dirent.isFile()) return 'file';\n  if (dirent.isSymbolicLink()) return 'symlink';\n  return 'other';\n}\n\n/** Сначала каталоги, затем остальные; внутри — по имени в порядке кодовых единиц. */\nfunction byKindAndName(a: WorktreeEntry, b: WorktreeEntry): number {\n  const rank = Number(a.kind !== 'dir') - Number(b.kind !== 'dir');\n  if (rank !== 0) return rank;\n  return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;\n}\n\n/** Размер файла по lstat; не прочитался (файл удалили между шагами) — запись без размера. */\nasync function withSize(dir: string, entry: WorktreeEntry): Promise<WorktreeEntry> {\n  try {\n    return { ...entry, size: (await lstat(join(dir, entry.name))).size };\n  } catch {\n    return entry;\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/git/git.const.d.ts

@@ -0,0 +1,4 @@
+/** Таймаут обычной команды: локальный репозиторий отвечает за секунды, зависание — сбой. */
+export declare const GIT_TIMEOUT_MS = 120000;
+/** `git worktree add` выкладывает всё дерево: на больших репозиториях это минуты. */
+export declare const GIT_CHECKOUT_TIMEOUT_MS = 600000;

package/dist/git/git.lib.d.ts

@@ -0,0 +1,90 @@
+import type { WorktreeStatusEntry } from '../contract/contract.types.ts';
+import type { GitRunOptions, GitRun, CommitOutcome, RebaseOutcome, ChangedFile, FileSide } from './git.types.ts';
+/**
+ * Git-команда не выполнилась: код, вывод и признак таймаута — для ошибки `git_failed` и журнала.
+ * Аргументы и вывод маскируются здесь, до сообщения (D-272): stderr git и хуков несёт
+ * `https://user:token@host`, а текст ошибки уходит в ответ, receipt, `worktrees.error` и события.
+ * Поля `args` и `stderr` хранят уже замаскированные значения; `stdout` (до 16 МиБ, его никто не
+ * читает) маскируется при первом чтении, чтобы не держать event loop на каждом сбое git.
+ */
+export declare class GitError extends Error {
+    #private;
+    readonly args: readonly string[];
+    readonly exitCode: number | null;
+    readonly stderr: string;
+    readonly timedOut: boolean;
+    constructor(args: readonly string[], exitCode: number | null, stderr: string, stdout?: string, timedOut?: boolean);
+    get stdout(): string;
+}
+/** Остановка host: очередь отклоняется, запущенные git убиваются (задания пула отменяемы, §3.1). */
+export declare function closeGitPool(): void;
+/** Пул закрыт остановкой host: сбой git тогда не повод писать failed — доделает старт. */
+export declare function isGitPoolClosed(): boolean;
+/** Только для тестов: снова открыть пул после closeGitPool. */
+export declare function reopenGitPool(): void;
+/** Запуск git в cwd: ненулевой код вне okCodes, таймаут или переполнение вывода — GitError. */
+export declare function runGit(args: readonly string[], cwd: string, options?: GitRunOptions): Promise<GitRun>;
+/** Корень рабочего дерева репозитория, в котором лежит path; не репозиторий или bare — GitError. */
+export declare function repoToplevel(path: string): Promise<string>;
+/** Ref резолвится в коммит: sha; нет такого ref — undefined. Ref идёт после `--end-of-options`. */
+export declare function resolveCommit(cwd: string, ref: string): Promise<string | undefined>;
+/** Текущая ветка репозитория; HEAD отсоединён — undefined. */
+export declare function currentBranch(repoPath: string): Promise<string | undefined>;
+/** Имя проходит `git check-ref-format --branch`. */
+export declare function isValidBranchName(repoPath: string, branch: string): Promise<boolean>;
+/** Sha локальной ветки; ветки нет — undefined. */
+export declare function branchSha(repoPath: string, branch: string): Promise<string | undefined>;
+/** `git worktree add --no-track -b <branch> <path> <sha>` (§6.9): ветка без upstream. */
+export declare function addWorktree(repoPath: string, worktreePath: string, branch: string, baseSha: string): Promise<void>;
+/** Снимает с учёта репозитория worktree, чьих каталогов больше нет (после переноса в trash). */
+export declare function pruneWorktrees(repoPath: string): Promise<void>;
+/** Удаляет локальную ветку. */
+export declare function deleteBranch(repoPath: string, branch: string): Promise<void>;
+/** HEAD worktree: sha (40 или 64 hex). */
+export declare function headOf(worktreePath: string): Promise<string>;
+/**
+ * `git status --porcelain=v1 -z` → записи ревью. С -z имена приходят байт в байт, без
+ * кавычек и экранирования; у переименования и копии следом идёт запись исходного пути.
+ */
+export declare function statusEntries(worktreePath: string, untracked?: 'normal' | 'no'): Promise<WorktreeStatusEntry[]>;
+/** Есть незакоммиченные изменения (включая неотслеживаемые файлы вне .gitignore). */
+export declare function isDirty(worktreePath: string): Promise<boolean>;
+/** `git diff <sha>`: индекс и рабочий каталог против коммита. */
+export declare function diffAgainst(worktreePath: string, sha: string): Promise<string>;
+/**
+ * Коммитит изменения: `git add -A` и `git commit`, или только переданные пути — `git add` и
+ * `git commit --only` по ним, буквально (pathspec-магия вида `:(top)` от клиента не работает),
+ * так что прежде добавленное в индекс в коммит не попадает. Нечего коммитить — committed: false.
+ */
+export declare function commitChanges(worktreePath: string, message: string, paths?: readonly string[]): Promise<CommitOutcome>;
+/** Незавершённая операция git в worktree: rebase, merge, cherry-pick или revert; нет — undefined. */
+export declare function operationInProgress(worktreePath: string): Promise<string | undefined>;
+/**
+ * Rebase worktree на коммит. Чужой незавершённый rebase или merge и изменения отслеживаемых
+ * файлов — отказ без действий: работу агента вызов не трогает. Конфликт — список путей и
+ * `git rebase --abort` только для rebase, начатого этим вызовом; HEAD остаётся прежним.
+ */
+export declare function rebaseOnto(worktreePath: string, baseSha: string): Promise<RebaseOutcome>;
+/**
+ * Файлы отслеживаемого дерева, изменённые против коммита: статус из `--name-status -z -M`,
+ * счётчики строк и признак бинарного (`-\t-`) из `--numstat -z -M`. Пути — байт в байт (-z);
+ * у переименования и копии в записи два пути (исходный, затем новый). Неотслеживаемые файлы
+ * здесь не видны: их отдаёт untrackedFiles.
+ */
+export declare function changedFiles(worktreePath: string, sha: string): Promise<ChangedFile[]>;
+/** Неотслеживаемые файлы вне .gitignore: `ls-files --others --exclude-standard -z`. */
+export declare function untrackedFiles(worktreePath: string): Promise<string[]>;
+/**
+ * Содержимое файла в коммите (`git cat-file`); файла там нет (или это не блоб) — undefined.
+ * Больше maxBytes — усечённая сторона без текста: объект целиком не читается, поэтому бинарность
+ * такого файла неизвестна (binary: false).
+ */
+export declare function showBlob(worktreePath: string, sha: string, path: string, maxBytes: number): Promise<FileSide | undefined>;
+/**
+ * Рабочее состояние файла для ревью. Корень и родитель файла резолвятся realpath и обязаны
+ * лежать внутри worktree (иначе PathEscapeError). Симлинк не разыменовывается: показывается
+ * текст ссылки, как у git, но ссылка, чья цель выходит за worktree, — PathEscapeError.
+ * Нет файла, это каталог или не обычный файл (fifo, сокет) — undefined; бинарный и больший
+ * maxBytes файлы текста не несут.
+ */
+export declare function readWorktreeFile(worktreePath: string, path: string, maxBytes: number): Promise<FileSide | undefined>;