@linghun/tui 0.1.0

package/dist/chunk-GTP2KPLY.js

@@ -0,0 +1,167 @@
+import {
+  appendGitOperationEvent,
+  performStablePoint,
+  performWorktreeCreate
+} from "./chunk-7ZE5JFAZ.js";
+import {
+  summarizeWorktreeRemovePlan
+} from "./chunk-6USL33ZO.js";
+import {
+  planManagedWorktreeRemove
+} from "./chunk-4EIC5BCT.js";
+
+// src/git-slash-runtime.ts
+function parseStablePointSlashArgs(args) {
+  let includeUntracked = false;
+  const messageParts = [];
+  for (const arg of args) {
+    if (arg === "--include-untracked") {
+      includeUntracked = true;
+      continue;
+    }
+    messageParts.push(arg);
+  }
+  const raw = messageParts.join(" ").trim();
+  const message = raw.replace(/^["'“‘]|["'”’]$/gu, "").trim();
+  return { message: message || void 0, includeUntracked };
+}
+function parseWorktreeSlashArgs(args) {
+  let name;
+  let branch;
+  let fromRef;
+  let force = false;
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--force") {
+      force = true;
+      continue;
+    }
+    if (arg === "--branch" || arg === "-b") {
+      branch = args[i + 1];
+      i += 1;
+      continue;
+    }
+    if (arg === "--from") {
+      fromRef = args[i + 1];
+      i += 1;
+      continue;
+    }
+    if (!name && !arg.startsWith("-")) {
+      name = arg;
+    }
+  }
+  return { name, branch, fromRef, force };
+}
+async function runStablePointCreateSlash(args, context, output, deps) {
+  const parsed = parseStablePointSlashArgs(args);
+  const sessionId = await deps.ensureSession(context);
+  if (context.permissionMode === "plan") {
+    const text = context.language === "en-US" ? "stable point was NOT created because Plan mode is read-only." : "stable point was NOT created because Plan mode is read-only. \u7A33\u5B9A\u70B9\u672A\u521B\u5EFA\uFF1A\u8BA1\u5212\u6A21\u5F0F\u53EA\u8BFB\u3002";
+    await appendGitOperationEvent(
+      deps.dispatch,
+      context,
+      sessionId,
+      {
+        operation: "stable_point_denied",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        project: context.projectPath,
+        includeUntracked: parsed.includeUntracked,
+        result: "plan_read_only",
+        source: "slash"
+      },
+      "warning"
+    );
+    deps.writeLine(output, text);
+    deps.writeStatus(output, context);
+    return;
+  }
+  const result = await performStablePoint(
+    context,
+    sessionId,
+    { message: parsed.message, includeUntracked: parsed.includeUntracked },
+    deps.dispatch
+  );
+  deps.writeLine(output, result.text);
+  deps.writeStatus(output, context);
+}
+async function runWorktreeCreateSlash(args, context, output, deps) {
+  const parsed = parseWorktreeSlashArgs(args);
+  if (!parsed.name) {
+    deps.writeLine(output, "\u7528\u6CD5\uFF1A/worktree create <name> [--branch <branch>] [--from <ref>]");
+    return;
+  }
+  const sessionId = await deps.ensureSession(context);
+  const result = await performWorktreeCreate(
+    context,
+    sessionId,
+    { name: parsed.name, branch: parsed.branch, fromRef: parsed.fromRef },
+    deps.dispatch
+  );
+  deps.writeLine(output, result.text);
+  deps.writeStatus(output, context);
+}
+async function runWorktreeRemoveSlash(args, context, output, deps) {
+  const parsed = parseWorktreeSlashArgs(args);
+  if (!parsed.name) {
+    deps.writeLine(output, "\u7528\u6CD5\uFF1A/worktree remove <name> [--force]");
+    return;
+  }
+  const sessionId = await deps.ensureSession(context);
+  const plan = await planManagedWorktreeRemove(context.projectPath, {
+    name: parsed.name,
+    force: parsed.force
+  });
+  const summary = summarizeWorktreeRemovePlan(plan, context.language);
+  if (summary.needsConfirmation && (plan.kind === "clean" || plan.kind === "dirty_force")) {
+    context.pendingLocalApproval = {
+      kind: "git_worktree_remove",
+      sessionId,
+      name: plan.name,
+      path: plan.path,
+      force: plan.kind === "dirty_force",
+      strong: summary.strong
+    };
+    await appendGitOperationEvent(
+      deps.dispatch,
+      context,
+      sessionId,
+      {
+        operation: "worktree_remove_requested",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        name: plan.name,
+        path: plan.path,
+        force: plan.kind === "dirty_force",
+        result: "pending_confirmation"
+      },
+      "info"
+    );
+    deps.writeLine(output, summary.text);
+    deps.writeStatus(output, context);
+    return;
+  }
+  if (plan.kind === "dirty_blocked" || plan.kind === "not_managed") {
+    await appendGitOperationEvent(
+      deps.dispatch,
+      context,
+      sessionId,
+      {
+        operation: "worktree_remove_denied",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        name: parsed.name,
+        reason: summary.text,
+        result: "denied"
+      },
+      "warning"
+    );
+  }
+  deps.writeLine(output, summary.text);
+  deps.writeStatus(output, context);
+}
+
+export {
+  parseStablePointSlashArgs,
+  parseWorktreeSlashArgs,
+  runStablePointCreateSlash,
+  runWorktreeCreateSlash,
+  runWorktreeRemoveSlash
+};

package/dist/chunk-GW5YDCRZ.js

@@ -0,0 +1,42 @@
+// src/shell/components/useAnchoredCursor.ts
+import { useBoxMetrics, useCursor } from "@linghun/ink-runtime";
+function getAbsoluteOrigin(node) {
+  if (!node) return null;
+  let x = 0;
+  let y = 0;
+  let cur = node;
+  while (cur && cur.nodeName !== "ink-root") {
+    const yogaNode = cur.yogaNode;
+    if (!yogaNode) return null;
+    const layout = yogaNode.getComputedLayout();
+    x += layout.left;
+    y += layout.top;
+    cur = cur.parentNode;
+  }
+  if (!cur || cur.nodeName !== "ink-root") return null;
+  return { x, y };
+}
+function useAnchoredCursor(declared, anchorRef, capability) {
+  const { setCursorPosition } = useCursor();
+  useBoxMetrics(anchorRef);
+  let desired;
+  if (declared && capability.cursorPositioning) {
+    let origin = null;
+    try {
+      origin = getAbsoluteOrigin(anchorRef.current);
+    } catch {
+      origin = null;
+    }
+    if (origin) {
+      desired = {
+        x: Math.max(0, Math.round(origin.x + declared.col)),
+        y: Math.max(0, Math.round(origin.y + declared.row))
+      };
+    }
+  }
+  setCursorPosition(desired);
+}
+
+export {
+  useAnchoredCursor
+};

package/dist/chunk-H3T4EF5F.js

@@ -0,0 +1,87 @@
+// src/shell/models/permission-elevation.ts
+var TEXT = {
+  "zh-CN": {
+    allowOnce: "\u672C\u6B21\u5141\u8BB8",
+    allowAlways: "\u59CB\u7EC8\u5141\u8BB8\u8BE5\u5DE5\u5177",
+    deny: "\u62D2\u7EDD",
+    details: "\u67E5\u770B\u8BE6\u60C5",
+    hintAllowOnce: "\u4EC5\u672C\u6B21\u6267\u884C\uFF1B\u89C4\u5219\u4E0D\u4F1A\u843D\u76D8",
+    hintAllowAlwaysLow: "\u672A\u6765\u540C\u5DE5\u5177\u9759\u9ED8\u901A\u8FC7\uFF08\u4F4E\u98CE\u9669\uFF09",
+    hintAllowAlwaysMedium: "\u672A\u6765\u540C\u5DE5\u5177\u9759\u9ED8\u901A\u8FC7\uFF08\u4E2D\u98CE\u9669\uFF0C\u8BF7\u786E\u8BA4\uFF09",
+    hintAllowAlwaysHigh: "\u672A\u6765\u540C\u5DE5\u5177\u9759\u9ED8\u901A\u8FC7\uFF08\u9AD8\u98CE\u9669\uFF0C\u5EFA\u8BAE\u5148 details\uFF09",
+    hintAllowAlwaysHidden: "\u5DF2\u5B58\u5728 allow \u89C4\u5219\uFF0C\u65E0\u9700\u91CD\u590D\u843D\u76D8",
+    hintDeny: "\u672C\u6B21\u62D2\u7EDD\uFF1B\u53EF\u7EE7\u7EED\u5BF9\u8BDD\u8C03\u6574\u65B9\u6848",
+    hintDetails: "\u5C55\u5F00\u539F\u56E0 / \u5F71\u54CD\u8303\u56F4 / \u5B89\u5168\u7EA7\u522B"
+  },
+  "en-US": {
+    allowOnce: "Allow once",
+    allowAlways: "Always allow this tool",
+    deny: "Deny",
+    details: "Details",
+    hintAllowOnce: "One-shot allow; no rule is persisted",
+    hintAllowAlwaysLow: "Future invocations of this tool pass silently (low risk)",
+    hintAllowAlwaysMedium: "Future invocations of this tool pass silently (medium risk)",
+    hintAllowAlwaysHigh: "Future invocations of this tool pass silently (HIGH risk; review details first)",
+    hintAllowAlwaysHidden: "An allow rule already exists; persisting again is redundant",
+    hintDeny: "Reject this invocation; you can keep iterating",
+    hintDetails: "Show reason / scope / safety level"
+  }
+};
+function hasExistingAllowRule(rules, toolName, risk) {
+  for (const rule of rules) {
+    if (rule.effect !== "allow") continue;
+    if (rule.toolName !== toolName && rule.toolName !== "*") continue;
+    if (rule.risk && rule.risk !== risk) continue;
+    return true;
+  }
+  return false;
+}
+function buildAllowAlwaysHint(text, risk) {
+  if (risk === "high") return text.hintAllowAlwaysHigh;
+  if (risk === "medium") return text.hintAllowAlwaysMedium;
+  return text.hintAllowAlwaysLow;
+}
+function buildAllowAlwaysSlashCommand(toolName, risk) {
+  return `/permissions add allow ${toolName} ${risk}`;
+}
+function describeAllowAlwaysCommand(toolName, risk) {
+  return buildAllowAlwaysSlashCommand(toolName, risk);
+}
+function buildElevationOptions(input) {
+  const text = TEXT[input.language];
+  const alreadyAllowed = hasExistingAllowRule(input.existingRules, input.toolName, input.risk);
+  const options = [];
+  options.push({
+    id: "allow_once",
+    shortcut: "y",
+    label: text.allowOnce,
+    hint: text.hintAllowOnce
+  });
+  if (!alreadyAllowed) {
+    options.push({
+      id: "allow_always_tool",
+      shortcut: "a",
+      label: text.allowAlways,
+      hint: buildAllowAlwaysHint(text, input.risk)
+    });
+  }
+  options.push({
+    id: "deny",
+    shortcut: "n",
+    label: text.deny,
+    hint: text.hintDeny
+  });
+  options.push({
+    id: "details",
+    shortcut: "d",
+    label: text.details,
+    hint: text.hintDetails
+  });
+  return options;
+}
+
+export {
+  hasExistingAllowRule,
+  describeAllowAlwaysCommand,
+  buildElevationOptions
+};

package/dist/chunk-HAEU6OTS.js

@@ -0,0 +1,381 @@
+// src/architecture-boundary.ts
+var DEFAULT_THRESHOLDS = {
+  maxFileLines: 800,
+  maxFunctionLines: 200,
+  maxNestingDepth: 4,
+  maxExportsForGodFile: 40,
+  godFileLineThreshold: 1500
+};
+var SUBSTANTIAL_ADDED_LINES = 40;
+var MULTI_EDIT_SUBSTANTIAL_COUNT = 3;
+var BASH_FILE_WRITE_PATTERN = /(?:^|\s|[;&|]\s*)(>>?|tee(?:\s+-a)?)\s+(\S+)|cat\s+<<\s*\S+\s*>>?\s*(\S+)/giu;
+function detectBashFileWriteTargets(command) {
+  const targets = [];
+  const cleaned = command.replace(/^```(?:bash|sh|shell)?\s*/iu, "").replace(/```\s*$/u, "");
+  const regex = BASH_FILE_WRITE_PATTERN;
+  for (const match of cleaned.matchAll(regex)) {
+    const target = (match[2] ?? match[3] ?? "").replace(/^["']|["']$/gu, "");
+    if (target && !target.startsWith("/dev/") && !target.startsWith("$") && !target.startsWith("~")) {
+      targets.push(target);
+    }
+  }
+  return targets;
+}
+var LAYER_ORDER = {
+  shared: 0,
+  config: 1,
+  core: 2,
+  providers: 3,
+  tools: 4,
+  tui: 5,
+  cli: 6
+};
+function checkFileBoundaries(metrics, thresholds = DEFAULT_THRESHOLDS) {
+  const violations = [];
+  if (metrics.lineCount > thresholds.maxFileLines) {
+    const severity = metrics.lineCount > thresholds.godFileLineThreshold ? "critical" : "warning";
+    violations.push({
+      kind: metrics.lineCount > thresholds.godFileLineThreshold ? "god-file" : "large-file",
+      severity,
+      file: metrics.path,
+      detail: `${metrics.lineCount} lines (threshold: ${thresholds.maxFileLines})`,
+      metric: metrics.lineCount,
+      threshold: thresholds.maxFileLines,
+      suggestion: severity === "critical" ? "Mark for staged extraction in a future phase; do not expand further." : "Avoid adding more logic to this file; prefer adjacent modules."
+    });
+  }
+  if (metrics.functionLengths) {
+    for (const fn of metrics.functionLengths) {
+      if (fn.lines > thresholds.maxFunctionLines) {
+        violations.push({
+          kind: "large-function",
+          severity: fn.lines > thresholds.maxFunctionLines * 2 ? "critical" : "warning",
+          file: metrics.path,
+          detail: `Function "${fn.name}" is ${fn.lines} lines (threshold: ${thresholds.maxFunctionLines})`,
+          metric: fn.lines,
+          threshold: thresholds.maxFunctionLines,
+          suggestion: "Extract sub-logic into focused helpers within the same module."
+        });
+      }
+    }
+  }
+  if (metrics.maxNestingDepth !== void 0 && metrics.maxNestingDepth > thresholds.maxNestingDepth) {
+    violations.push({
+      kind: "deep-nesting",
+      severity: metrics.maxNestingDepth > thresholds.maxNestingDepth + 2 ? "critical" : "warning",
+      file: metrics.path,
+      detail: `Max nesting depth: ${metrics.maxNestingDepth} (threshold: ${thresholds.maxNestingDepth})`,
+      metric: metrics.maxNestingDepth,
+      threshold: thresholds.maxNestingDepth,
+      suggestion: "Use early returns, guard clauses, or extract nested logic."
+    });
+  }
+  if (metrics.exportCount !== void 0 && metrics.exportCount > thresholds.maxExportsForGodFile && metrics.lineCount > thresholds.maxFileLines) {
+    if (!violations.some((v) => v.kind === "god-file")) {
+      violations.push({
+        kind: "god-file",
+        severity: "critical",
+        file: metrics.path,
+        detail: `${metrics.exportCount} exports + ${metrics.lineCount} lines indicates a god file`,
+        metric: metrics.exportCount,
+        threshold: thresholds.maxExportsForGodFile,
+        suggestion: "Mark for staged extraction; do not add new exports without extracting existing ones."
+      });
+    }
+  }
+  return violations;
+}
+function detectCrossLayerImports(filePath, importSources) {
+  const fileLayer = inferLayer(filePath);
+  if (fileLayer === void 0) return [];
+  const violations = [];
+  for (const source of importSources) {
+    const sourceLayer = inferLayerFromImport(source);
+    if (sourceLayer === void 0) continue;
+    const fileOrder = LAYER_ORDER[fileLayer];
+    const sourceOrder = LAYER_ORDER[sourceLayer];
+    if (fileOrder !== void 0 && sourceOrder !== void 0 && sourceOrder > fileOrder) {
+      violations.push({
+        kind: "cross-layer-import",
+        severity: "warning",
+        file: filePath,
+        detail: `Layer "${fileLayer}" imports from higher layer "${sourceLayer}" via "${source}"`,
+        suggestion: "Move shared logic to a lower layer or use dependency inversion."
+      });
+    }
+  }
+  return violations;
+}
+function detectCircularDependencyRisk(fileA, fileB) {
+  const aImportsB = fileA.importSources.some(
+    (source) => source.includes(extractModuleName(fileB.path))
+  );
+  const bImportsA = fileB.importSources.some(
+    (source) => source.includes(extractModuleName(fileA.path))
+  );
+  if (aImportsB && bImportsA) {
+    return {
+      kind: "circular-dependency-risk",
+      severity: "warning",
+      file: `${fileA.path} <-> ${fileB.path}`,
+      detail: `Mutual import detected between ${fileA.path} and ${fileB.path}`,
+      suggestion: "Extract shared types/logic into a third module to break the cycle."
+    };
+  }
+  return void 0;
+}
+function checkBoundaries(files, thresholds = DEFAULT_THRESHOLDS) {
+  const violations = [];
+  for (const file of files) {
+    violations.push(...checkFileBoundaries(file, thresholds));
+    if (file.importSources) {
+      violations.push(...detectCrossLayerImports(file.path, file.importSources));
+    }
+  }
+  const hasCritical = violations.some((v) => v.severity === "critical");
+  const hasBlocking = hasCritical;
+  return {
+    violations,
+    hasBlocking,
+    hasCritical,
+    summary: formatBoundaryCheckSummary(violations)
+  };
+}
+function validateChangeDeclaration(declaration) {
+  const warnings = [];
+  if (!declaration.files || declaration.files.length === 0) {
+    warnings.push("Change declaration missing: files list is empty.");
+  }
+  if (!declaration.mainPath) {
+    warnings.push("Change declaration missing: mainPath not specified.");
+  }
+  if (!declaration.verificationLevel) {
+    warnings.push("Change declaration missing: verificationLevel not specified.");
+  }
+  if (declaration.files && declaration.files.length > 3 && (!declaration.realSmokeRequired || declaration.realSmokeRequired.length === 0)) {
+    warnings.push(
+      "Large change (>3 files) without realSmokeRequired items. Declare what needs real smoke verification."
+    );
+  }
+  return warnings;
+}
+function checkBoundaryEditPreflight(request, thresholds = DEFAULT_THRESHOLDS) {
+  if (!request.targetExists || request.reportArtifact) {
+    return { decision: "allow", reason: "new file or report artifact" };
+  }
+  const existingSource = request.existingSource;
+  if (existingSource === void 0) {
+    return { decision: "allow", reason: "existing content unavailable" };
+  }
+  const metrics = estimateFileMetrics(request.path, existingSource);
+  const isLargeFile = metrics.lineCount > thresholds.maxFileLines || metrics.lineCount > thresholds.godFileLineThreshold || (metrics.exportCount ?? 0) > thresholds.maxExportsForGodFile && metrics.lineCount > thresholds.maxFileLines;
+  if (!isLargeFile) {
+    return { decision: "allow", reason: "target is below large-file thresholds" };
+  }
+  if (request.toolName === "Bash") {
+    return {
+      decision: "confirm",
+      reason: "large-file-boundary",
+      path: request.path,
+      lineCount: metrics.lineCount,
+      threshold: thresholds.maxFileLines,
+      estimatedAddedLines: 0
+    };
+  }
+  const estimatedAddedLines = estimateAddedLines(request.toolName, request.input);
+  if (!isSubstantialEdit(request.toolName, request.input, estimatedAddedLines)) {
+    return { decision: "allow", reason: "small local edit" };
+  }
+  return {
+    decision: "confirm",
+    reason: "large-file-boundary",
+    path: request.path,
+    lineCount: metrics.lineCount,
+    threshold: thresholds.maxFileLines,
+    estimatedAddedLines
+  };
+}
+function formatBoundaryViolations(violations) {
+  if (violations.length === 0) return "No architecture boundary violations detected.";
+  const grouped = /* @__PURE__ */ new Map();
+  for (const v of violations) {
+    const list = grouped.get(v.kind) ?? [];
+    list.push(v);
+    grouped.set(v.kind, list);
+  }
+  const lines = [`Architecture boundary violations: ${violations.length}`];
+  for (const [kind, items] of grouped) {
+    lines.push(`  ${kind} (${items.length}):`);
+    for (const item of items.slice(0, 5)) {
+      lines.push(`    - [${item.severity}] ${item.file}: ${item.detail}`);
+    }
+    if (items.length > 5) {
+      lines.push(`    ... and ${items.length - 5} more`);
+    }
+  }
+  return lines.join("\n");
+}
+function estimateFileMetrics(path, source) {
+  const lines = source.split(/\r?\n/);
+  const lineCount = lines.length;
+  let exportCount = 0;
+  for (const line of lines) {
+    if (/^\s*export\s+(function|const|let|var|class|type|interface|enum|default)\b/.test(line)) {
+      exportCount++;
+    }
+  }
+  const functionLengths = estimateFunctionLengths(lines);
+  const maxNestingDepth = estimateMaxNesting(lines);
+  const importSources = [];
+  for (const line of lines) {
+    const match = line.match(/(?:from|import)\s+["']([^"']+)["']/);
+    if (match?.[1]) {
+      importSources.push(match[1]);
+    }
+  }
+  return {
+    path,
+    lineCount,
+    exportCount,
+    importSources,
+    functionLengths,
+    maxNestingDepth
+  };
+}
+function inferLayer(filePath) {
+  const normalized = filePath.replace(/\\/g, "/").toLowerCase();
+  const match = normalized.match(/packages\/([^/]+)\//);
+  if (match?.[1]) return match[1];
+  const appMatch = normalized.match(/apps\/([^/]+)\//);
+  if (appMatch) return "cli";
+  return void 0;
+}
+function inferLayerFromImport(source) {
+  const match = source.match(/@linghun\/([^/]+)/);
+  if (match?.[1]) return match[1];
+  return void 0;
+}
+function extractModuleName(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const parts = normalized.split("/");
+  const fileName = parts[parts.length - 1] ?? "";
+  return fileName.replace(/\.(ts|tsx|js|jsx)$/, "");
+}
+function estimateFunctionLengths(lines) {
+  const results = [];
+  const functionStartPattern = /^\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)|^\s*(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s*)?\(/;
+  let currentFunction;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!currentFunction) {
+      const match = functionStartPattern.exec(line);
+      if (match) {
+        const name = match[1] ?? match[2] ?? "anonymous";
+        currentFunction = { name, startLine: i, braceDepth: 0 };
+      }
+    }
+    if (currentFunction) {
+      for (const char of line) {
+        if (char === "{") currentFunction.braceDepth++;
+        if (char === "}") currentFunction.braceDepth--;
+      }
+      if (currentFunction.braceDepth <= 0 && i > currentFunction.startLine) {
+        const length = i - currentFunction.startLine + 1;
+        if (length > 10) {
+          results.push({ name: currentFunction.name, lines: length });
+        }
+        currentFunction = void 0;
+      }
+    }
+  }
+  if (currentFunction) {
+    const length = lines.length - currentFunction.startLine;
+    if (length > 10) {
+      results.push({ name: currentFunction.name, lines: length });
+    }
+  }
+  return results;
+}
+function estimateMaxNesting(lines) {
+  let maxDepth = 0;
+  let currentDepth = 0;
+  for (const line of lines) {
+    const stripped = line.replace(/\/\/.*$/, "").replace(/"[^"]*"|'[^']*'|`[^`]*`/g, "");
+    for (const char of stripped) {
+      if (char === "{" || char === "(" || char === "[") {
+        currentDepth++;
+        if (currentDepth > maxDepth) maxDepth = currentDepth;
+      }
+      if (char === "}" || char === ")" || char === "]") {
+        currentDepth = Math.max(0, currentDepth - 1);
+      }
+    }
+  }
+  return maxDepth;
+}
+function estimateAddedLines(toolName, input) {
+  if (typeof input !== "object" || input === null) {
+    return 0;
+  }
+  if (toolName === "Write") {
+    const content = input.content;
+    return typeof content === "string" ? lineCountOf(content) : 0;
+  }
+  if (toolName === "Edit") {
+    const oldText = input.oldText;
+    const newText = input.newText;
+    if (typeof newText !== "string") return 0;
+    const oldLines = typeof oldText === "string" ? lineCountOf(oldText) : 0;
+    return Math.max(0, lineCountOf(newText) - oldLines);
+  }
+  const edits = input.edits;
+  if (!Array.isArray(edits)) {
+    return 0;
+  }
+  return edits.reduce((total, item) => {
+    if (typeof item !== "object" || item === null) return total;
+    const oldText = item.oldText;
+    const newText = item.newText;
+    if (typeof newText !== "string") return total;
+    const oldLines = typeof oldText === "string" ? lineCountOf(oldText) : 0;
+    return total + Math.max(0, lineCountOf(newText) - oldLines);
+  }, 0);
+}
+function isSubstantialEdit(toolName, input, estimatedAddedLines) {
+  if (estimatedAddedLines >= SUBSTANTIAL_ADDED_LINES) {
+    return true;
+  }
+  if (toolName !== "MultiEdit" || typeof input !== "object" || input === null) {
+    return false;
+  }
+  const edits = input.edits;
+  return Array.isArray(edits) && edits.length >= MULTI_EDIT_SUBSTANTIAL_COUNT;
+}
+function lineCountOf(text) {
+  if (text.length === 0) return 0;
+  return text.split(/\r?\n/).length;
+}
+function formatBoundaryCheckSummary(violations) {
+  if (violations.length === 0) return "clean";
+  const critical = violations.filter((v) => v.severity === "critical").length;
+  const warning = violations.filter((v) => v.severity === "warning").length;
+  const info = violations.filter((v) => v.severity === "info").length;
+  const parts = [];
+  if (critical > 0) parts.push(`${critical} critical`);
+  if (warning > 0) parts.push(`${warning} warning`);
+  if (info > 0) parts.push(`${info} info`);
+  return parts.join(", ");
+}
+
+export {
+  DEFAULT_THRESHOLDS,
+  detectBashFileWriteTargets,
+  checkFileBoundaries,
+  detectCrossLayerImports,
+  detectCircularDependencyRisk,
+  checkBoundaries,
+  validateChangeDeclaration,
+  checkBoundaryEditPreflight,
+  formatBoundaryViolations,
+  estimateFileMetrics
+};