@linghun/tui 0.1.0

package/dist/chunk-PBIPV4LD.js

@@ -0,0 +1,494 @@
+import {
+  classifyVerificationLevel
+} from "./chunk-CRSLDQOA.js";
+import {
+  classifyRuntimePath,
+  classifyStartupPath
+} from "./chunk-VIBENDE3.js";
+import {
+  isFallbackWorkspaceReferenceSnapshot
+} from "./chunk-ZJK25VFP.js";
+import {
+  getSelectedModelRuntime
+} from "./chunk-3LT6OWQ2.js";
+import {
+  formatCooldownDoctorLine
+} from "./chunk-EBACIBJP.js";
+
+// src/terminal-readiness-runtime.ts
+import { spawnSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+function createTerminalReadinessView(context) {
+  const runtime = getSelectedModelRuntime(context);
+  const latestCache = context.cache.history.at(-1);
+  const runtimeVisibleBackground = context.backgroundTasks.filter(
+    isReadinessRuntimeVisibleBackgroundTask
+  );
+  const needsAttentionBackground = context.backgroundTasks.filter(
+    (task) => isReadinessNeedsAttentionBackgroundTask(task)
+  );
+  const webSourceEvidence = context.evidence.some((evidence) => evidence.kind === "web_source") ? "present" : "missing";
+  const projectDoctor = createProjectDoctorLite(context);
+  const sourceDrift = createSourceOfTruthDriftLite(context);
+  const contextPicker = createContextPickerLite(context, webSourceEvidence);
+  const rollbackCoach = createRollbackCoachLite(context);
+  const costPreview = createTaskCostPreviewLite(context);
+  return {
+    projectPath: context.projectPath,
+    provider: runtime.provider,
+    model: runtime.model,
+    endpointProfile: runtime.endpointProfile,
+    // D.14A-R-Fix P1-5 — 只有本会话观察到真实 provider usage（cache history 有记录）
+    // 才算 live-verified；仅配置存在不算 provider 可用。lastProviderFailure 时不算
+    // live-verified，由 providerFailure 分支接管为 fail。
+    providerLiveVerified: context.cache.history.length > 0 && !context.lastProviderFailure,
+    permissionMode: context.permissionMode,
+    language: context.language,
+    index: {
+      status: context.index.status,
+      changedFiles: context.index.changedFiles ?? null,
+      staleHint: context.index.staleHint
+    },
+    cache: {
+      latestHitRate: latestCache?.hitRate ?? null,
+      compacted: context.cache.compacted,
+      // D.13V — fallback snapshot 不再当 ready；区分 ready / stale-fallback / missing。
+      workspaceSnapshot: (() => {
+        const latest = context.cache.workspaceReference.latest;
+        if (!latest?.workspaceSnapshot) return "missing";
+        if (isFallbackWorkspaceReferenceSnapshot(latest)) return "stale-fallback";
+        return "ready";
+      })()
+    },
+    memory: {
+      projectRules: context.memory.projectRulesError ? "unreadable" : context.memory.projectRulesExists ? "found" : "missing",
+      candidates: context.memory.candidates.length,
+      accepted: context.memory.accepted.length
+    },
+    mcp: {
+      enabled: context.mcp.enabled,
+      servers: context.mcp.servers.length,
+      tools: context.mcp.tools.length,
+      errors: context.mcp.servers.filter((server) => server.status === "error").length
+    },
+    background: {
+      total: runtimeVisibleBackground.length,
+      running: runtimeVisibleBackground.filter((task) => task.status === "running").length,
+      blocked: needsAttentionBackground.length
+    },
+    verification: context.lastVerification ? {
+      status: context.lastVerification.status,
+      summary: context.lastVerification.summary,
+      unverified: context.lastVerification.unverified.length,
+      risk: context.lastVerification.risk.length
+    } : void 0,
+    providerFailure: context.lastProviderFailure ? {
+      code: context.lastProviderFailure.code,
+      provider: context.lastProviderFailure.provider,
+      model: context.lastProviderFailure.model,
+      endpointProfile: context.lastProviderFailure.endpointProfile,
+      summary: context.lastProviderFailure.summary
+    } : void 0,
+    freshness: { webSourceEvidence },
+    runtimePath: createRuntimePathForReadiness(context),
+    verificationLevel: createVerificationLevelForReadiness(context),
+    startupPath: createStartupPathForReadiness(),
+    projectDoctor,
+    sourceDrift,
+    contextPicker,
+    rollbackCoach,
+    costPreview,
+    problems: createTerminalProblems(context, webSourceEvidence, {
+      projectDoctor,
+      sourceDrift,
+      contextPicker,
+      rollbackCoach,
+      costPreview
+    })
+  };
+}
+function createRuntimePathForReadiness(_context) {
+  const isTTY = Boolean(process.stdout.isTTY);
+  const isCI = Boolean(process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI);
+  const envOverride = process.env.LINGHUN_TUI_RENDER_MODE;
+  const forcedLegacy = envOverride === "legacy";
+  const inkAvailable = isTTY && !isCI && !forcedLegacy;
+  const marker = classifyRuntimePath({
+    isTTY,
+    inkAvailable,
+    envOverride,
+    forcedLegacy,
+    isCI
+  });
+  return {
+    path: marker.path,
+    kind: marker.kind,
+    canClaimMature: marker.canClaimMature,
+    degradedReason: marker.degradedReason
+  };
+}
+function createVerificationLevelForReadiness(context) {
+  const lastVerification = context.lastVerification;
+  if (!lastVerification) {
+    return {
+      level: "source",
+      canClaimPass: false,
+      canClaimMature: false,
+      upgradeBlocked: false
+    };
+  }
+  const status = lastVerification.status;
+  const commands = lastVerification.commands ?? [];
+  const hasRunnerError = commands.some((c) => Boolean(c.runnerError));
+  const hasPartialOrSkipped = commands.some(
+    (c) => c.status === "partial" || c.status === "skipped" || c.status === "stale" || c.status === "cancelled" || c.status === "timeout"
+  );
+  const hasFailedCommand = commands.some((c) => c.status === "fail");
+  const smokePassed = commands.some(
+    (c) => c.kind === "smoke" && c.status === "pass" && c.synthetic !== true
+  );
+  const realProcessObserved = status === "pass" && smokePassed && !hasRunnerError && !hasPartialOrSkipped && !hasFailedCommand && lastVerification.unverified.length === 0;
+  const simulatedOrPartial = status === "partial" || lastVerification.unverified.length > 0 || hasPartialOrSkipped;
+  const fallbackUsed = hasRunnerError || status === "stale";
+  const buildPassed = status === "pass" && !simulatedOrPartial && !fallbackUsed;
+  const localTestRunner = commands.some((c) => c.kind === "test");
+  const classification = classifyVerificationLevel({
+    realProcessObserved,
+    simulatedOrPartial,
+    fallbackUsed,
+    buildPassed,
+    localTestRunner
+  });
+  return {
+    level: classification.level,
+    canClaimPass: classification.canClaimPass,
+    canClaimMature: classification.canClaimMature,
+    upgradeBlocked: classification.upgradeBlocked,
+    blockReason: classification.blockReason
+  };
+}
+function createStartupPathForReadiness() {
+  const isSourceExecution = Boolean(
+    process.argv[1]?.endsWith(".ts") || process.env.LINGHUN_DEV_MODE || process.env.VITEST
+  );
+  const isDistExecution = Boolean(
+    process.argv[1]?.includes("/dist/") || process.argv[1]?.includes("\\dist\\")
+  );
+  const isGlobalBin = Boolean(
+    process.argv[1]?.includes("/bin/") || process.argv[1]?.includes("\\bin\\")
+  );
+  const marker = classifyStartupPath({
+    isSourceExecution,
+    isDistExecution,
+    isGlobalBin
+  });
+  return {
+    entryKind: marker.entryKind,
+    isVerifiedCurrent: marker.isVerifiedCurrent,
+    staleRisk: marker.staleRisk,
+    staleReason: marker.staleReason
+  };
+}
+function createProjectDoctorLite(context) {
+  const packageJson = readPackageJsonLite(context.projectPath);
+  const scriptsRecord = readRecord(packageJson?.scripts);
+  const scripts = Object.keys(scriptsRecord).sort();
+  const packageManager = readPackageManagerLite(packageJson, context.projectPath);
+  const configFiles = [
+    "package.json",
+    "tsconfig.json",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "vitest.config.js",
+    "vitest.config.mjs",
+    "biome.json",
+    "biome.jsonc",
+    "pnpm-lock.yaml"
+  ].filter((file) => existsSync(join(context.projectPath, file)));
+  const ciFiles = [".github/workflows/ci.yml", ".github/workflows/ci.yaml"].filter(
+    (file) => existsSync(join(context.projectPath, file))
+  );
+  const packageManagerReady = packageManager.startsWith("pnpm@") || packageManager === "pnpm" && existsSync(join(context.projectPath, "pnpm-lock.yaml"));
+  const vitestReady = hasAnyFile(context.projectPath, [
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "vitest.config.js",
+    "vitest.config.mjs"
+  ]) || hasPackageDependency(packageJson, "vitest");
+  const biomeReady = hasAnyFile(context.projectPath, ["biome.json", "biome.jsonc"]) || hasPackageDependency(packageJson, "@biomejs/biome");
+  const projectRulesExists = context.memory.projectRulesExists || existsSync(join(context.projectPath, "LINGHUN.md"));
+  const requiredChecks = [
+    { id: "script:test", ok: typeof scriptsRecord.test === "string" },
+    { id: "script:typecheck", ok: typeof scriptsRecord.typecheck === "string" },
+    { id: "script:check", ok: typeof scriptsRecord.check === "string" },
+    { id: "script:build", ok: typeof scriptsRecord.build === "string" },
+    { id: "tsconfig", ok: existsSync(join(context.projectPath, "tsconfig.json")) },
+    { id: "vitest", ok: vitestReady },
+    { id: "biome", ok: biomeReady },
+    { id: "pnpm/corepack", ok: packageManagerReady },
+    { id: "ci-workflow", ok: ciFiles.length > 0 },
+    { id: "LINGHUN.md", ok: projectRulesExists }
+  ];
+  const unknown = [
+    packageJson ? void 0 : "package.json",
+    context.memory.projectRulesError ? "LINGHUN.md:unreadable" : void 0,
+    ...requiredChecks.filter((check) => !check.ok).map((check) => check.id)
+  ].filter((item) => Boolean(item));
+  const status = unknown.length === 0 ? "pass" : "partial";
+  return {
+    status,
+    packageManager,
+    scripts,
+    configFiles,
+    ciFiles,
+    projectRules: context.memory.projectRulesError ? "unreadable" : projectRulesExists ? "found" : "missing",
+    checks: requiredChecks.map((check) => `${check.id}=${check.ok ? "ok" : "missing"}`),
+    unknown
+  };
+}
+function createSourceOfTruthDriftLite(context) {
+  const requiredDocs = [
+    "README.md",
+    "README.en.md",
+    "WHITEPAPER.md",
+    "WHITEPAPER.en.md",
+    "LICENSE",
+    "APP_BRIDGE_MANIFEST.schema.json",
+    "docs/developers/capability-runtime-app-bridge.md",
+    "docs/developers/capability-runtime-app-bridge.en.md"
+  ];
+  const checked = requiredDocs.filter((file) => existsSync(join(context.projectPath, file)));
+  const issues = requiredDocs.filter((file) => !checked.includes(file)).map((file) => `missing:${file}`);
+  const readme = readTextFileLite(join(context.projectPath, "README.md"));
+  const whitepaper = readTextFileLite(join(context.projectPath, "WHITEPAPER.md"));
+  if (readme && !readme.includes("npm install -g @linghun/cli")) {
+    issues.push("readme:install-command");
+  }
+  if (readme && !readme.includes("App Bridge")) issues.push("readme:app-bridge");
+  if (whitepaper && !whitepaper.includes("\u53CD\u5E7B\u89C9")) issues.push("whitepaper:anti-hallucination");
+  if (whitepaper && !whitepaper.includes("Windows")) issues.push("whitepaper:windows");
+  const status = issues.length === 0 ? "pass" : checked.length > 0 ? "partial" : "unknown";
+  return {
+    status,
+    checked,
+    issues,
+    nextAction: issues.length === 0 ? "/doctor report" : "sync public README/whitepaper docs"
+  };
+}
+function createContextPickerLite(context, webSourceEvidence) {
+  const wsLatest = context.cache.workspaceReference.latest;
+  const hasWorkspaceSnapshot = Boolean(wsLatest?.workspaceSnapshot) && !isFallbackWorkspaceReferenceSnapshot(wsLatest);
+  const refs = [
+    context.memory.projectRulesExists ? "project-rules" : void 0,
+    hasWorkspaceSnapshot ? "workspace-snapshot" : void 0,
+    context.index.status !== "missing" ? "index-status" : void 0,
+    context.lastVerification ? "verification-last" : void 0,
+    context.backgroundTasks.length > 0 ? "background-tasks" : void 0,
+    webSourceEvidence === "present" ? "web-source-evidence" : void 0
+  ].filter((item) => Boolean(item));
+  const evidenceKinds = [...new Set(context.evidence.map((evidence) => evidence.kind))].sort();
+  const indexFreshness = context.index.status === "ready" ? "fresh" : context.index.status === "stale" ? "stale" : "unknown";
+  const hasEvidenceRef = evidenceKinds.length > 0 || Boolean(context.lastVerification);
+  const status = context.memory.projectRulesExists && indexFreshness === "fresh" && hasWorkspaceSnapshot && hasEvidenceRef ? "pass" : refs.length > 0 ? "partial" : "unknown";
+  return {
+    status,
+    refs,
+    evidenceKinds,
+    indexFreshness
+  };
+}
+function createRollbackCoachLite(context) {
+  const gitStatusLines = readGitStatusShortLite(context.projectPath);
+  const fallbackChangedFiles = /* @__PURE__ */ new Set([
+    ...context.tools.changedFiles,
+    ...context.checkpoints.flatMap((checkpoint) => checkpoint.changedFiles)
+  ]);
+  const changedFiles = gitStatusLines ? gitStatusLines.length : fallbackChangedFiles.size;
+  const untrackedFiles = gitStatusLines ? gitStatusLines.filter((line) => line.startsWith("??")).length : 0;
+  const gitStatus = gitStatusLines ? gitStatusLines.length > 0 ? "dirty" : "clean" : "unavailable";
+  const hasBlockedWork = context.backgroundTasks.some(
+    (task) => ["blocked", "failed", "timeout", "stale"].includes(task.status)
+  );
+  const status = gitStatus === "unavailable" ? "unknown" : hasBlockedWork || changedFiles > 0 ? "partial" : "pass";
+  return {
+    status,
+    changedFiles,
+    untrackedFiles,
+    checkpoints: context.checkpoints.length,
+    gitStatus,
+    mode: "advisory-only",
+    nextAction: changedFiles > 0 ? "review /diff and create a normal checkpoint before manual rollback" : gitStatus === "unavailable" ? "run git status --short manually before rollback decisions" : "no rollback action suggested"
+  };
+}
+function createTaskCostPreviewLite(context) {
+  const labels = ["local-only", "no-network", "no-real-smoke", "advisory-estimate"];
+  const visibleBackgroundCount = context.backgroundTasks.filter(
+    isReadinessRuntimeVisibleBackgroundTask
+  ).length;
+  if (context.lastVerification) labels.push("may-run-tests");
+  if (visibleBackgroundCount > 0) labels.push("background-visible");
+  if (context.lastProviderFailure) labels.push("provider-diagnostic-only");
+  return {
+    status: "partial",
+    level: context.lastVerification || visibleBackgroundCount > 0 ? "medium" : "light",
+    labels,
+    nextAction: "advisory estimate only; confirm before tests, provider calls, network, or release actions"
+  };
+}
+function readPackageJsonLite(projectPath) {
+  try {
+    return JSON.parse(readFileSync(join(projectPath, "package.json"), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function hasAnyFile(projectPath, files) {
+  return files.some((file) => existsSync(join(projectPath, file)));
+}
+function hasPackageDependency(packageJson, dependency) {
+  if (!packageJson) return false;
+  return ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"].some(
+    (section) => typeof readRecord(packageJson[section])[dependency] === "string"
+  );
+}
+function readGitStatusShortLite(projectPath) {
+  const result = spawnSync("git", ["status", "--short"], {
+    cwd: projectPath,
+    encoding: "utf8",
+    shell: false,
+    timeout: 2e3,
+    windowsHide: true
+  });
+  if (result.error || result.status !== 0) return void 0;
+  return result.stdout.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
+}
+function readPackageManagerLite(packageJson, projectPath) {
+  if (typeof packageJson?.packageManager === "string") return packageJson.packageManager;
+  if (existsSync(join(projectPath, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(projectPath, "package-lock.json"))) return "npm";
+  if (existsSync(join(projectPath, "yarn.lock"))) return "yarn";
+  return "unknown";
+}
+function readRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function readTextFileLite(path) {
+  try {
+    return readFileSync(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function createTerminalProblems(context, webSourceEvidence, lite) {
+  const problems = [];
+  if (context.lastVerification && context.lastVerification.status !== "pass") {
+    problems.push({
+      source: "verification",
+      severity: context.lastVerification.status === "fail" || context.lastVerification.status === "timeout" ? "error" : "warning",
+      summary: `${context.lastVerification.status}: ${context.lastVerification.summary}`,
+      nextAction: context.lastVerification.nextAction,
+      detailRef: "/verify last"
+    });
+  }
+  if (context.lastProviderFailure) {
+    problems.push({
+      source: "provider",
+      severity: "error",
+      summary: `${context.lastProviderFailure.code}: ${context.lastProviderFailure.provider}/${context.lastProviderFailure.model}`,
+      nextAction: "/model doctor",
+      detailRef: "/details evidence"
+    });
+  }
+  const cooldownDoctorLine = formatCooldownDoctorLine(context.providerBreaker, context.language);
+  if (cooldownDoctorLine) {
+    problems.push({
+      source: "provider",
+      severity: "warning",
+      summary: cooldownDoctorLine,
+      nextAction: "/model doctor"
+    });
+  }
+  for (const task of context.backgroundTasks.filter(isReadinessProblemBackgroundTask)) {
+    problems.push({
+      source: "background",
+      severity: task.status === "failed" || task.status === "timeout" ? "error" : "warning",
+      summary: `${task.kind} ${task.status}: ${task.userVisibleSummary}`,
+      nextAction: task.nextAction ?? "/background",
+      detailRef: "/background"
+    });
+  }
+  if (webSourceEvidence === "missing") {
+    problems.push({
+      source: "freshness",
+      severity: "warning",
+      summary: "No web_source evidence in the current session; current/external facts must stay unverified.",
+      nextAction: "Mark latest/current/external facts as unverified unless evidence is added.",
+      detailRef: "/details evidence"
+    });
+  }
+  if (context.index.status === "stale" || context.index.status === "error") {
+    problems.push({
+      source: "index",
+      severity: context.index.status === "error" ? "error" : "warning",
+      summary: `index status ${context.index.status}${context.index.staleHint ? `; ${context.index.staleHint}` : ""}`,
+      nextAction: "/index doctor",
+      detailRef: "/index status"
+    });
+  }
+  if (lite.projectDoctor.status !== "pass") {
+    problems.push({
+      source: "project",
+      severity: "warning",
+      summary: `Project Doctor Lite ${lite.projectDoctor.status}; unknown ${lite.projectDoctor.unknown.join(",") || "none"}`,
+      nextAction: "/doctor project"
+    });
+  }
+  if (lite.sourceDrift.status !== "pass") {
+    problems.push({
+      source: "drift",
+      severity: "warning",
+      summary: `Source-of-Truth Drift Linter Lite issues ${lite.sourceDrift.issues.join(",") || "none"}`,
+      nextAction: lite.sourceDrift.nextAction
+    });
+  }
+  if (lite.contextPicker.status !== "pass") {
+    problems.push({
+      source: "context",
+      severity: "warning",
+      summary: `Context Picker Lite refs ${lite.contextPicker.refs.length}; index ${lite.contextPicker.indexFreshness}`,
+      nextAction: "/doctor project"
+    });
+  }
+  if (lite.rollbackCoach.status !== "pass") {
+    problems.push({
+      source: "rollback",
+      severity: "info",
+      summary: `Rollback Coach Lite changed files ${lite.rollbackCoach.changedFiles}; untracked ${lite.rollbackCoach.untrackedFiles}; checkpoints ${lite.rollbackCoach.checkpoints}; read-only advice only`,
+      nextAction: lite.rollbackCoach.nextAction
+    });
+  }
+  if (lite.costPreview.status !== "pass") {
+    problems.push({
+      source: "cost",
+      severity: "warning",
+      summary: `Task Cost Preview Lite level ${lite.costPreview.level}`,
+      nextAction: lite.costPreview.nextAction
+    });
+  }
+  return problems;
+}
+function isReadinessRuntimeVisibleBackgroundTask(task) {
+  return task.status === "running" || task.status === "paused" || task.status === "blocked" || task.status === "failed" || task.status === "timeout";
+}
+function isReadinessNeedsAttentionBackgroundTask(task) {
+  return task.status === "paused" || task.status === "blocked" || task.status === "failed" || task.status === "timeout" || task.status === "stale";
+}
+function isReadinessProblemBackgroundTask(task) {
+  return task.status === "blocked" || task.status === "failed" || task.status === "timeout" || task.status === "stale";
+}
+
+export {
+  createTerminalReadinessView,
+  createVerificationLevelForReadiness
+};