@linghun/tui 0.1.0

package/dist/chunk-P277M7Z5.js

@@ -0,0 +1,303 @@
+import {
+  evaluateArchitectureAndCompletenessClaims,
+  evaluateFinalAnswerClaims,
+  extractStructuredFinalAnswerClaims,
+  finalAnswerHasCompletenessClassification,
+  hasArchitectureEvidenceForClaims
+} from "./chunk-K56D3X7S.js";
+import {
+  detectArchitectureDrift
+} from "./chunk-MVONSJEN.js";
+
+// src/final-answer-gate.ts
+function needsSolutionCompletenessReportClosure(context, assistantText) {
+  if (!context.solutionCompleteness.classificationRequired) {
+    return false;
+  }
+  return !/single_issue|systemic_gap/u.test(assistantText);
+}
+function runArchitectureAndCompletenessFinalGate(context, assistantText) {
+  if (!assistantText) {
+    return { status: "passed" };
+  }
+  const card = context.currentArchitectureCard;
+  let driftWarnings = [];
+  if (card) {
+    const drift = detectArchitectureDrift(card, { summary: assistantText });
+    driftWarnings = drift.warnings;
+  }
+  const verdict = evaluateArchitectureAndCompletenessClaims(
+    assistantText,
+    {
+      hasActiveCard: Boolean(card),
+      driftWarnings,
+      hasArchitectureEvidence: hasArchitectureEvidenceForClaims(context.evidence)
+    },
+    {
+      classificationRequired: context.solutionCompleteness.classificationRequired,
+      classification: context.solutionCompleteness.classification,
+      textHasClassification: finalAnswerHasCompletenessClassification(assistantText)
+    }
+  );
+  if (verdict.status === "needs_disclaimer") {
+    return { status: "needs_disclaimer", verdict };
+  }
+  return { status: "passed" };
+}
+function formatSolutionCompletenessReportBlock(context) {
+  const status = context.solutionCompleteness;
+  const classification = status.classification === "unknown" ? "systemic_gap" : status.classification;
+  const impact = status.impactAreas.length > 0 ? status.impactAreas.join(", ") : "unknown";
+  const severity = status.severity === "unknown" ? "blocking_P1" : status.severity;
+  return [
+    "Solution Completeness Gate report",
+    `- classification: ${classification}`,
+    `- impactAreas: ${impact}`,
+    `- severity: ${severity}`,
+    "- phaseBoundary: stay in the current approved scope; do not enter Beta or later roadmap stages automatically.",
+    "- validation: list focused tests/check/typecheck/build/diff-check before claiming closure."
+  ].join("\n");
+}
+function createHandoffPendingItems(evidence) {
+  return createPhase15BetaVerdictScope(evidence).uncoveredItems;
+}
+function createHandoffRiskItems(evidence) {
+  return createPhase15BetaVerdictScope(evidence).residualRisks;
+}
+function createPhase15BetaVerdictScope(evidence = [], transcript = []) {
+  const requiredEvidence = [
+    {
+      key: "real-tui-report-generation",
+      missing: "real TUI report-generation path lacks PASS evidence",
+      present: hasEvidenceClaim(
+        evidence,
+        /real[-\s]?tui.*report.*pass|report[-\s]?generation.*pass/iu
+      )
+    },
+    {
+      key: "deepseek-dual-provider-pass",
+      missing: "DeepSeek dual-provider live report evidence is missing",
+      present: hasEvidenceClaim(evidence, /deepseek.*(?:gate\s*f|dual[-\s]?provider).*pass/iu)
+    },
+    {
+      key: "openai-compatible-dual-provider-pass",
+      missing: "OpenAI-compatible dual-provider live report evidence is missing",
+      present: hasEvidenceClaim(
+        evidence,
+        /openai[-\s]?compatible.*(?:gate\s*f|dual[-\s]?provider).*pass/iu
+      )
+    },
+    {
+      key: "write-evidence",
+      missing: "report Write evidence is missing",
+      present: hasReportWriteEvidence(evidence)
+    },
+    {
+      key: "final-answer-report-reference",
+      missing: "final answer does not reference the generated report",
+      present: hasFinalAnswerReportReference(evidence, transcript)
+    }
+  ];
+  const hasBlockingGate = hasBlockingGateEvidence(evidence, transcript);
+  const uncoveredItems = requiredEvidence.filter((item) => !item.present).map((item) => item.missing);
+  const residualRisks = [];
+  if (uncoveredItems.length > 0) {
+    residualRisks.push(
+      "live provider basic text PASS is not live provider tool/report PASS",
+      "mock provider PASS and focused test PASS cannot prove Beta readiness"
+    );
+  }
+  if (hasBlockingGate) {
+    uncoveredItems.push("blocking gate evidence still contains SKIPPED, PARTIAL, or BLOCKED");
+    residualRisks.push("blocking gate is not fully closed");
+  }
+  return {
+    scope: "beta",
+    status: uncoveredItems.length === 0 ? "PASS" : "PARTIAL",
+    evidenceRefs: evidence.filter((item) => isBetaVerdictEvidence(item)).map((item) => item.id),
+    validationCommands: [
+      "corepack pnpm test -- --run packages/tui/src/index.test.ts packages/tui/src/natural-command-bridge.test.ts",
+      "corepack pnpm test",
+      "corepack pnpm check",
+      "corepack pnpm typecheck",
+      "corepack pnpm build",
+      "git diff --check"
+    ],
+    uncoveredItems,
+    residualRisks,
+    nextAction: uncoveredItems.length === 0 ? "All required Beta readiness evidence is present. User confirmation is still required before Beta." : "Fix or re-smoke the real provider + real TUI report-generation path before declaring Beta readiness."
+  };
+}
+function hasEvidenceClaim(evidence, pattern) {
+  return evidence.some(
+    (item) => pattern.test([item.summary, item.source, ...item.supportsClaims].join(" "))
+  );
+}
+function hasReportWriteEvidence(evidence) {
+  return evidence.some(
+    (item) => item.kind === "command_output" && (item.source === "Write" || item.supportsClaims.includes("Write")) && /report|报告|\.md\b/iu.test([item.summary, item.source, ...item.supportsClaims].join(" "))
+  );
+}
+function hasFinalAnswerReportReference(evidence, transcript) {
+  if (hasEvidenceClaim(evidence, /final answer.*report|最终回答.*报告|reference.*report/iu)) {
+    return true;
+  }
+  return [...transcript].reverse().some(
+    (event) => event.type === "assistant_text_delta" && /(?:report[\w./\\-]*\.md|报告文件|生成的报告|saved report)/iu.test(event.text)
+  );
+}
+function hasBlockingGateEvidence(evidence, transcript) {
+  const blockingStatusPattern = /(?:blocking|阻塞|gate|闸门).{0,80}(?:SKIPPED|PARTIAL|BLOCKED|跳过|部分|阻塞)|(?:SKIPPED|PARTIAL|BLOCKED).{0,80}(?:blocking|阻塞|gate|闸门)/iu;
+  if (hasEvidenceClaim(evidence, blockingStatusPattern)) {
+    return true;
+  }
+  return transcript.some((event) => {
+    if (event.type === "verification_end") {
+      return event.report.status === "partial" || event.report.commands.some(
+        (command) => command.status === "partial" || command.status === "skipped"
+      );
+    }
+    if (event.type === "system_event" || event.type === "assistant_text_delta") {
+      const text = event.type === "system_event" ? event.message : event.text;
+      return blockingStatusPattern.test(text);
+    }
+    return false;
+  });
+}
+function isBetaVerdictEvidence(item) {
+  return /real[-\s]?tui.*report.*pass|report[-\s]?generation.*pass|deepseek.*(?:gate\s*f|dual[-\s]?provider).*pass|openai[-\s]?compatible.*(?:gate\s*f|dual[-\s]?provider).*pass|final answer.*report|最终回答.*报告/iu.test(
+    [item.summary, item.source, ...item.supportsClaims].join(" ")
+  ) || hasReportWriteEvidence([item]);
+}
+function checkClaimSupport(claim, context) {
+  const structuredClaims = extractStructuredFinalAnswerClaims(claim);
+  if (structuredClaims.some((item) => item.kind === "beta_readiness")) {
+    return {
+      status: "needs_disclaimer",
+      unsupportedClaims: structuredClaims.filter((item) => item.kind === "beta_readiness").map((item) => item.phrase),
+      verdict: createPhase15BetaVerdictScope(context.evidence)
+    };
+  }
+  if (structuredClaims.length === 0) {
+    const nlCheck = detectNaturalLanguageHighRiskClaims(claim);
+    if (nlCheck.status !== "passed") return nlCheck;
+    return { status: "passed", unsupportedClaims: [] };
+  }
+  if (structuredClaims.some(
+    (item) => item.kind === "architecture_boundary" || item.kind === "completeness"
+  )) {
+    const extended = runArchitectureAndCompletenessFinalGate(context, claim);
+    if (extended.status === "needs_disclaimer") {
+      return {
+        status: "needs_disclaimer",
+        unsupportedClaims: extended.verdict.matchedClaims.map((item) => item.phrase)
+      };
+    }
+  }
+  const verdict = evaluateFinalAnswerClaims(claim, context.evidence);
+  if (verdict.status === "passed") {
+    return { status: "passed", unsupportedClaims: [] };
+  }
+  return {
+    status: "needs_disclaimer",
+    unsupportedClaims: structuredClaims.map((item) => item.phrase)
+  };
+}
+var HIGH_RISK_NL_CLAIM_PATTERNS = [
+  // ── Chinese patterns（无 \b，CJK 字符无需 ASCII 单词边界）──
+  {
+    regex: /(?:测试(?:都|全部|已经|已)?通过|全部测试通过|所有测试(?:都)?通过)/iu,
+    label: "\u6D4B\u8BD5\u901A\u8FC7"
+  },
+  {
+    regex: /(?:已完成|已修复并已验证|已修复且已验证|已经完成修复|已经修复)/iu,
+    label: "\u5DF2\u5B8C\u6210/\u5DF2\u4FEE\u590D"
+  },
+  {
+    regex: /已修复/iu,
+    label: "\u5DF2\u4FEE\u590D"
+  },
+  {
+    regex: /(?:全部通过|全部完成|完全通过)/iu,
+    label: "\u5168\u90E8\u901A\u8FC7"
+  },
+  {
+    regex: /(?:可上线|可以上线|达到上线标准)/iu,
+    label: "\u53EF\u4E0A\u7EBF"
+  },
+  {
+    regex: /(?:全部(?:单元)?测试(?:已|已经)?通过|所有(?:单元)?测试(?:已|已经)?通过)/iu,
+    label: "\u6D4B\u8BD5\u901A\u8FC7"
+  },
+  // ── English / mixed patterns（保留 \b，避免误伤普通词）──
+  {
+    regex: /\b(?:beta\s*ready|ready\s*for\s*beta|production\s*ready)\b/iu,
+    label: "beta ready"
+  },
+  {
+    regex: /\b(?:smoke\s*(?:test\s*)?pass(?:ed)?)\b/iu,
+    label: "smoke pass"
+  },
+  {
+    regex: /smoke\s*通过/iu,
+    label: "smoke pass"
+  },
+  {
+    regex: /\bPASS\b/u,
+    label: "PASS"
+  }
+];
+function detectNaturalLanguageHighRiskClaims(text) {
+  const hitLabels = /* @__PURE__ */ new Set();
+  for (const { regex, label } of HIGH_RISK_NL_CLAIM_PATTERNS) {
+    if (regex.test(text)) {
+      hitLabels.add(label);
+    }
+  }
+  if (hitLabels.size > 0) {
+    return {
+      status: "needs_disclaimer",
+      unsupportedClaims: Array.from(hitLabels)
+    };
+  }
+  return { status: "passed", unsupportedClaims: [] };
+}
+function formatClaimCheck(result, language) {
+  if (result.verdict) {
+    const evidenceStatus = result.verdict.evidenceRefs.length > 0 ? "recorded" : "missing";
+    const validation = result.verdict.validationCommands.join("; ");
+    const uncovered = result.verdict.uncoveredItems.join("; ");
+    const risks = result.verdict.residualRisks.join("; ");
+    return language === "en-US" ? [
+      `Claim Checker: verdict ${result.verdict.status}; scope ${result.verdict.scope}.`,
+      `Evidence is ${evidenceStatus}; use /details evidence for details.`,
+      `Validation: ${validation}.`,
+      `Uncovered: ${uncovered}.`,
+      `Risk: ${risks}.`,
+      `Next: ${result.verdict.nextAction}`
+    ].join("\n") : [
+      `Claim Checker\uFF1Averdict ${result.verdict.status}\uFF1Bscope ${result.verdict.scope}\u3002`,
+      `\u8BC1\u636E\u5DF2${evidenceStatus === "recorded" ? "\u8BB0\u5F55" : "\u7F3A\u5931"}\uFF1B\u8BE6\u60C5\u7528 /details evidence\u3002`,
+      `Validation\uFF1A${validation}\u3002`,
+      `Uncovered\uFF1A${uncovered}\u3002`,
+      `Risk\uFF1A${risks}\u3002`,
+      `Next\uFF1A${result.verdict.nextAction}`
+    ].join("\n");
+  }
+  if (result.status === "passed") {
+    return language === "en-US" ? "Claim check passed." : "Claim Checker\uFF1A\u901A\u8FC7\u3002";
+  }
+  const claims = result.unsupportedClaims.join(", ");
+  return language === "en-US" ? `Claim lacks evidence: ${claims}. Gather matching evidence or remove the claim.` : `Claim Checker\uFF1A\u7F3A\u5C11\u8BC1\u636E\uFF1A${claims}\u3002\u8BF7\u8865\u9F50\u5339\u914D\u8BC1\u636E\u6216\u79FB\u9664\u8BE5\u58F0\u660E\u3002`;
+}
+
+export {
+  needsSolutionCompletenessReportClosure,
+  runArchitectureAndCompletenessFinalGate,
+  formatSolutionCompletenessReportBlock,
+  createHandoffPendingItems,
+  createHandoffRiskItems,
+  createPhase15BetaVerdictScope,
+  checkClaimSupport,
+  formatClaimCheck
+};

package/dist/chunk-P4CPRJLI.js

@@ -0,0 +1,65 @@
+// src/undo-ring.ts
+function createUndoRing(maxSize = 50, debounceMs = 500) {
+  return {
+    entries: [],
+    pointer: 0,
+    maxSize,
+    lastPushTime: 0,
+    debounceMs
+  };
+}
+function undoRingPush(ring, buffer, now = Date.now()) {
+  const withinDebounce = ring.entries.length > 0 && now - ring.lastPushTime < ring.debounceMs;
+  if (withinDebounce) {
+    const entries2 = [...ring.entries];
+    entries2[ring.pointer] = buffer;
+    return { ...ring, entries: entries2, lastPushTime: now };
+  }
+  if (ring.entries.length === 0) {
+    return {
+      ...ring,
+      entries: [buffer],
+      pointer: 0,
+      lastPushTime: now
+    };
+  }
+  const nextPointer = (ring.pointer + 1) % ring.maxSize;
+  const entries = [...ring.entries];
+  if (entries.length < ring.maxSize) {
+    entries.push(buffer);
+  } else {
+    entries[nextPointer] = buffer;
+  }
+  return {
+    ...ring,
+    entries,
+    pointer: nextPointer,
+    lastPushTime: now
+  };
+}
+function undoRingPop(ring) {
+  if (ring.entries.length <= 1) {
+    return { ring, buffer: void 0 };
+  }
+  const prevPointer = ring.pointer === 0 ? ring.entries.length - 1 : ring.pointer - 1;
+  const buffer = ring.entries[prevPointer];
+  return {
+    ring: { ...ring, pointer: prevPointer },
+    buffer
+  };
+}
+function undoRingReset(ring) {
+  return {
+    ...ring,
+    entries: [],
+    pointer: 0,
+    lastPushTime: 0
+  };
+}
+
+export {
+  createUndoRing,
+  undoRingPush,
+  undoRingPop,
+  undoRingReset
+};