@linghun/tui 0.1.0

package/dist/chunk-VIBENDE3.js

@@ -0,0 +1,152 @@
+// src/runtime-path-marker.ts
+function classifyRuntimePath(input) {
+  if (input.envOverride) {
+    const path = parseEnvOverridePath(input.envOverride);
+    return {
+      path,
+      kind: path === "ink" ? "main" : "fallback",
+      isMainPath: path === "ink",
+      isFallback: path !== "ink",
+      canClaimMature: path === "ink",
+      degradedReason: path !== "ink" ? `env-override=${input.envOverride}` : void 0,
+      detectionMethod: "env-override"
+    };
+  }
+  if (input.forcedLegacy) {
+    return {
+      path: "forced-legacy",
+      kind: "fallback",
+      isMainPath: false,
+      isFallback: true,
+      canClaimMature: false,
+      degradedReason: "forced-legacy-by-config",
+      detectionMethod: "forced-by-config"
+    };
+  }
+  if (input.isTTY === false || input.isCI) {
+    return {
+      path: "non-tty",
+      kind: "fallback",
+      isMainPath: false,
+      isFallback: true,
+      canClaimMature: false,
+      degradedReason: input.isCI ? "ci-environment" : "non-tty-output",
+      detectionMethod: "tty-probe"
+    };
+  }
+  if (input.inkAvailable && input.isTTY) {
+    return {
+      path: "ink",
+      kind: "main",
+      isMainPath: true,
+      isFallback: false,
+      canClaimMature: true,
+      detectionMethod: "ink-available"
+    };
+  }
+  if (input.isTTY) {
+    return {
+      path: "plain",
+      kind: "fallback",
+      isMainPath: false,
+      isFallback: true,
+      canClaimMature: false,
+      degradedReason: "ink-unavailable",
+      detectionMethod: "tty-probe"
+    };
+  }
+  return {
+    path: "plain",
+    kind: "fallback",
+    isMainPath: false,
+    isFallback: true,
+    canClaimMature: false,
+    degradedReason: "unable-to-determine-tty",
+    detectionMethod: "default"
+  };
+}
+function classifyStartupPath(input) {
+  const entryKind = inferEntryKind(input);
+  const staleRisk = hasStaleRisk(entryKind, input);
+  return {
+    entryKind,
+    isVerifiedCurrent: !staleRisk && entryKind === "source",
+    staleRisk,
+    staleReason: staleRisk ? getStaleReason(entryKind, input) : void 0
+  };
+}
+function canClaimTuiMaturity(marker) {
+  return marker.isMainPath && marker.canClaimMature;
+}
+function canClaimCurrentVerification(marker) {
+  return marker.isVerifiedCurrent && !marker.staleRisk;
+}
+function detectRuntimePathInflation(claimedStatus, marker) {
+  const lower = claimedStatus.toLowerCase();
+  const isMatureClaim = lower.includes("mature") || lower.includes("ready") || lower.includes("production") || lower.includes("ink-verified");
+  if (isMatureClaim && !marker.canClaimMature) {
+    return `Runtime path inflation: claimed "${claimedStatus}" but actual path is "${marker.path}" (${marker.kind}). ${marker.degradedReason ?? "fallback-active"}`;
+  }
+  return void 0;
+}
+function formatRuntimePathMarker(marker) {
+  const parts = [
+    `path ${marker.path}`,
+    `kind ${marker.kind}`,
+    `detection ${marker.detectionMethod}`
+  ];
+  if (marker.degradedReason) {
+    parts.push(`degraded ${marker.degradedReason}`);
+  }
+  if (!marker.canClaimMature) {
+    parts.push("mature not claimable");
+  }
+  return parts.join("; ");
+}
+function formatStartupPathMarker(marker) {
+  const parts = [`entry ${marker.entryKind}`, `verified ${marker.isVerifiedCurrent}`];
+  if (marker.staleRisk) {
+    parts.push(`stale risk ${marker.staleReason ?? "true"}`);
+  }
+  return parts.join("; ");
+}
+function parseEnvOverridePath(value) {
+  const lower = value.toLowerCase().trim();
+  if (lower === "ink") return "ink";
+  if (lower === "plain") return "plain";
+  if (lower === "non-tty" || lower === "nontty") return "non-tty";
+  if (lower === "legacy" || lower === "forced-legacy") return "forced-legacy";
+  return "plain";
+}
+function inferEntryKind(input) {
+  if (input.isSourceExecution) return "source";
+  if (input.isDistExecution) return "dist";
+  if (input.isGlobalBin) return "global-bin";
+  if (input.isDesktopCmd) return "desktop-cmd";
+  return "unknown";
+}
+function hasStaleRisk(entryKind, input) {
+  if (entryKind === "source") return false;
+  if (entryKind === "dist" || entryKind === "global-bin" || entryKind === "desktop-cmd") {
+    return true;
+  }
+  if (entryKind === "unknown") return true;
+  return !input.packageVersion;
+}
+function getStaleReason(entryKind, _input) {
+  if (entryKind === "dist") return "dist-may-be-outdated";
+  if (entryKind === "global-bin") return "global-bin-may-be-outdated";
+  if (entryKind === "desktop-cmd") return "desktop-cmd-may-be-outdated";
+  if (entryKind === "unknown") return "unknown-entry-point";
+  return "cannot-verify-currency";
+}
+
+export {
+  classifyRuntimePath,
+  classifyStartupPath,
+  canClaimTuiMaturity,
+  canClaimCurrentVerification,
+  detectRuntimePathInflation,
+  formatRuntimePathMarker,
+  formatStartupPathMarker
+};

package/dist/chunk-VTQL23UM.js

@@ -0,0 +1,302 @@
+import {
+  truncateDisplay
+} from "./chunk-OMZYPQVA.js";
+
+// src/memory-extraction-runtime.ts
+import { randomUUID } from "crypto";
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { join } from "path";
+var MEMORY_MANIFEST_FILE = "MEMORY.md";
+var MEMORY_TOPICS_DIR = "topics";
+var MEMORY_SUMMARY_WIDTH = 240;
+var TOPIC_BODY_WIDTH = 800;
+var MEMORY_TAXONOMY = [
+  "user",
+  "feedback",
+  "project",
+  "reference"
+];
+var UNSAVEABLE_PATTERNS = [
+  {
+    id: "code_structure",
+    pattern: /\b(?:src|packages|apps|docs)[\\/][\w./-]+|(?:function|class|interface|type)\s+\w+/iu
+  },
+  {
+    id: "git_history",
+    pattern: /\b(?:git log|commit|branch|rebase|merge|stash|HEAD|SHA)\b|[a-f0-9]{7,40}/iu
+  },
+  {
+    id: "temporary_task",
+    pattern: /(?:本轮|当前阶段|临时|todo|next step|handoff|pre-smoke\s+\d|阶段进度|交付文档)/iu
+  },
+  {
+    id: "debug_recipe",
+    pattern: /(?:复现步骤|debug|stack trace|完整日志|error log|traceback|报错全文|stdout|stderr)/iu
+  },
+  {
+    id: "existing_rule",
+    pattern: /(?:AGENTS\.md|LINGHUN\.md|已有规则|全局工作规则|project-doc)/iu
+  },
+  {
+    id: "secret",
+    pattern: /(?:api[_-]?key|token|secret|password|credential|authorization|sk-[A-Za-z0-9_-]{12,}|ghp_[A-Za-z0-9]{20,}|-----BEGIN (?:RSA |EC |DSA )?PRIVATE KEY-----)/iu
+  },
+  {
+    id: "full_dump",
+    pattern: /(?:完整 transcript|完整索引|完整日志|raw tool_result|raw evidence|full transcript|full index)/iu
+  }
+];
+function decideMemoryExtraction(input) {
+  const text = input.recentMessages.map((item) => item.trim()).filter(Boolean).join("\n");
+  if (text.length < 8) return { action: "no-op", reason: "empty_or_too_short" };
+  if (text.length > 2400) return { action: "no-op", reason: "too_long_for_safe_extraction" };
+  const blocked = findUnsavableReason(text);
+  if (blocked) return { action: "no-op", reason: "unsaveable_content", blockedBy: blocked };
+  const taxonomy = classifyTaxonomy(text);
+  if (!taxonomy) return { action: "no-op", reason: "no_long_lived_fact" };
+  const summary = summarizeLongLivedFact(text, taxonomy);
+  if (!summary) return { action: "no-op", reason: "insufficient_specificity" };
+  const summaryBlocked = findUnsavableReason(summary);
+  if (summaryBlocked) {
+    return { action: "no-op", reason: "unsaveable_summary", blockedBy: summaryBlocked };
+  }
+  const topic = topicForSummary(summary, taxonomy);
+  const disabled = findRelatedMemory(input.disabled, taxonomy, topic, summary);
+  if (disabled) {
+    return { action: "no-op", reason: "disabled_existing_memory" };
+  }
+  const existing = findRelatedMemory(input.accepted, taxonomy, topic, summary);
+  const duplicate = findRelatedMemory(
+    [...input.accepted, ...input.disabled, ...input.candidates ?? []],
+    taxonomy,
+    topic,
+    summary
+  );
+  if (duplicate && normalizeText(duplicate.summary) === normalizeText(summary)) {
+    return { action: "no-op", reason: "duplicate_existing_memory" };
+  }
+  return {
+    action: existing ? "update" : "create",
+    id: existing?.id ?? randomUUID(),
+    taxonomy,
+    topic,
+    scope: taxonomy === "user" || taxonomy === "feedback" ? "user" : "project",
+    summary,
+    source: "memory-extraction:turn",
+    sourceRefs: ["turn:recent"],
+    ...existing ? { matchedExistingId: existing.id } : {}
+  };
+}
+async function applyMemoryExtractionDecision(input) {
+  if (input.decision.action === "no-op") {
+    return { decision: input.decision };
+  }
+  const now = (input.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const memory = {
+    ...input.existing ?? {},
+    id: input.decision.id,
+    scope: input.decision.scope,
+    status: "accepted",
+    taxonomy: input.decision.taxonomy,
+    topic: input.decision.topic,
+    summary: input.decision.summary,
+    source: input.decision.source,
+    sourceRefs: input.decision.sourceRefs,
+    risk: "low",
+    inferred: true,
+    createdAt: input.existing?.createdAt ?? now
+  };
+  await writeAutoMemoryFiles(input.memoryDir, memory, now);
+  return { decision: input.decision, memory };
+}
+async function writeAutoMemoryFiles(memoryDir, memory, updatedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  const topic = memory.topic ?? topicForSummary(memory.summary, memory.taxonomy ?? "project");
+  await mkdir(join(memoryDir, MEMORY_TOPICS_DIR), { recursive: true });
+  await writeFile(
+    join(memoryDir, MEMORY_TOPICS_DIR, `${topic}.md`),
+    formatTopicMarkdown(memory, updatedAt),
+    "utf8"
+  );
+  const manifest = await readManifest(memoryDir);
+  const next = upsertManifestEntry(manifest, {
+    id: memory.id,
+    taxonomy: memory.taxonomy ?? "project",
+    topic,
+    scope: memory.scope === "session" ? "project" : memory.scope,
+    summary: memory.summary,
+    status: memory.status === "disabled" ? "disabled" : "accepted",
+    updatedAt
+  });
+  await writeManifest(memoryDir, next);
+}
+async function refreshAutoMemoryFiles(memoryDir, accepted, disabled) {
+  await mkdir(join(memoryDir, MEMORY_TOPICS_DIR), { recursive: true });
+  const activeIds = new Set([...accepted, ...disabled].map((item) => item.id));
+  const entries = [...accepted, ...disabled].filter((item) => item.taxonomy && item.topic).map(
+    (item) => ({
+      id: item.id,
+      taxonomy: item.taxonomy ?? "project",
+      topic: item.topic ?? topicForSummary(item.summary, item.taxonomy ?? "project"),
+      scope: item.scope === "session" ? "project" : item.scope,
+      summary: item.summary,
+      status: item.status === "disabled" ? "disabled" : "accepted",
+      updatedAt: item.createdAt
+    })
+  );
+  for (const item of [...accepted, ...disabled].filter((entry) => entry.taxonomy && entry.topic)) {
+    await writeFile(
+      join(memoryDir, MEMORY_TOPICS_DIR, `${item.topic}.md`),
+      formatTopicMarkdown(item, item.createdAt),
+      "utf8"
+    );
+  }
+  const previous = await readManifest(memoryDir);
+  for (const entry of previous) {
+    if (!activeIds.has(entry.id)) {
+      await rm(join(memoryDir, MEMORY_TOPICS_DIR, `${entry.topic}.md`), { force: true });
+    }
+  }
+  await writeManifest(memoryDir, entries);
+}
+function findUnsavableReason(text) {
+  return UNSAVEABLE_PATTERNS.find((item) => item.pattern.test(text))?.id;
+}
+function classifyTaxonomy(text) {
+  if (/(?:反馈|不喜欢|太啰嗦|太慢|少废话|别空泛|feedback|too verbose|too slow|no fluff)/iu.test(text)) {
+    return "feedback";
+  }
+  if (/(?:我(?:习惯|偏好|喜欢|希望)|我的|用户偏好|prefer|preference|my default|i like|i usually)/iu.test(
+    text
+  )) {
+    return "user";
+  }
+  if (/(?:本项目|这个项目|仓库|workspace|project uses|project should|项目约定|验证命令|默认命令)/iu.test(
+    text
+  )) {
+    return "project";
+  }
+  if (/(?:参考|reference|文档|manual|external docs|公开行为|成熟行为)/iu.test(text)) {
+    return "reference";
+  }
+  return void 0;
+}
+function summarizeLongLivedFact(text, taxonomy) {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  const explicit = normalized.match(/(?:记住|remember|长期记忆|保存为记忆)[:：]?\s*(.{8,180})/iu)?.[1] ?? normalized.match(
+    /(?:我(?:习惯|偏好|喜欢|希望)|prefer|preference|my default|i like|i usually)[:：]?\s*(.{8,180})/iu
+  )?.[1] ?? normalized.match(
+    /(?:本项目|这个项目|项目约定|project uses|project should)[:：]?\s*(.{8,180})/iu
+  )?.[1] ?? normalized.match(/(?:反馈|feedback)[:：]?\s*(.{8,180})/iu)?.[1];
+  const candidate = (explicit ?? normalized).trim();
+  if (candidate.length < 8) return void 0;
+  const prefix = taxonomy === "feedback" ? "User feedback" : taxonomy === "user" ? "User preference" : taxonomy === "reference" ? "Reference note" : "Project memory";
+  return truncateDisplay(`${prefix}: ${candidate}`, MEMORY_SUMMARY_WIDTH);
+}
+function findRelatedMemory(memories, taxonomy, topic, summary) {
+  return memories.find((item) => {
+    if (item.taxonomy && item.taxonomy !== taxonomy) return false;
+    if (item.topic && item.topic === topic) return true;
+    if (hasMeaningfulOverlap(item.summary, summary)) return true;
+    return normalizeText(item.summary) === normalizeText(summary);
+  });
+}
+function hasMeaningfulOverlap(left, right) {
+  const leftWords = keywords(left);
+  const rightWords = keywords(right);
+  if (leftWords.size === 0 || rightWords.size === 0) return false;
+  let overlap = 0;
+  for (const word of leftWords) {
+    if (rightWords.has(word)) overlap += 1;
+  }
+  return overlap >= 2;
+}
+function keywords(text) {
+  return new Set(
+    normalizeText(text).split(/[^a-z0-9\u4e00-\u9fa5]+/iu).filter((word) => word.length >= 2).filter((word) => !["user", "preference", "project", "memory", "feedback"].includes(word))
+  );
+}
+function topicForSummary(summary, taxonomy) {
+  const normalized = normalizeText(summary).replace(/[^a-z0-9\u4e00-\u9fa5]+/giu, "-").replace(/^-+|-+$/g, "").slice(0, 48);
+  return `${taxonomy}-${normalized || "memory"}`;
+}
+function normalizeText(text) {
+  return text.toLocaleLowerCase().replace(/\s+/g, " ").trim();
+}
+async function readManifest(memoryDir) {
+  try {
+    return parseManifest(await readFile(join(memoryDir, MEMORY_MANIFEST_FILE), "utf8"));
+  } catch {
+    return [];
+  }
+}
+function parseManifest(content) {
+  const entries = [];
+  for (const line of content.split(/\r?\n/)) {
+    const match = line.match(
+      /^- \[([^\]]+)\] \((accepted|disabled)\) ([^/]+)\/([^:]+): (.+?) \(updated (.+)\)$/u
+    );
+    if (!match) continue;
+    const taxonomy = MEMORY_TAXONOMY.includes(match[3]) ? match[3] : "project";
+    entries.push({
+      id: match[1],
+      status: match[2],
+      taxonomy,
+      topic: match[4],
+      scope: taxonomy === "user" || taxonomy === "feedback" ? "user" : "project",
+      summary: match[5],
+      updatedAt: match[6]
+    });
+  }
+  return entries;
+}
+function upsertManifestEntry(entries, entry) {
+  return [entry, ...entries.filter((item) => item.id !== entry.id)].sort(
+    (a, b) => a.topic.localeCompare(b.topic)
+  );
+}
+async function writeManifest(memoryDir, entries) {
+  await mkdir(memoryDir, { recursive: true });
+  await writeFile(
+    join(memoryDir, MEMORY_MANIFEST_FILE),
+    [
+      "# Linghun Memory",
+      "",
+      "Long-lived auto memory index. LINGHUN.md remains project rules and is not rewritten here.",
+      "",
+      ...entries.map(
+        (entry) => `- [${entry.id}] (${entry.status}) ${entry.taxonomy}/${entry.topic}: ${truncateDisplay(entry.summary, MEMORY_SUMMARY_WIDTH)} (updated ${entry.updatedAt})`
+      ),
+      ""
+    ].join("\n"),
+    "utf8"
+  );
+}
+function formatTopicMarkdown(memory, updatedAt) {
+  return [
+    "---",
+    `id: ${memory.id}`,
+    `taxonomy: ${memory.taxonomy ?? "project"}`,
+    `scope: ${memory.scope}`,
+    `status: ${memory.status}`,
+    `updatedAt: ${updatedAt}`,
+    "---",
+    "",
+    `# ${memory.topic ?? "memory"}`,
+    "",
+    truncateDisplay(memory.summary.replace(/\s+/g, " "), TOPIC_BODY_WIDTH),
+    "",
+    `Source: ${memory.source}`,
+    `Refs: ${memory.sourceRefs.slice(0, 6).join(", ") || "none"}`,
+    ""
+  ].join("\n");
+}
+
+export {
+  MEMORY_MANIFEST_FILE,
+  MEMORY_TAXONOMY,
+  decideMemoryExtraction,
+  applyMemoryExtractionDecision,
+  writeAutoMemoryFiles,
+  refreshAutoMemoryFiles,
+  findUnsavableReason
+};