@linghun/tui 0.1.0

package/dist/chunk-QLRTQHTR.js

@@ -0,0 +1,744 @@
+import {
+  createWorkspaceReferenceCache
+} from "./chunk-ZJK25VFP.js";
+import {
+  MEMORY_LEARNING_STATE_FILE
+} from "./chunk-5H7RRF7C.js";
+import {
+  createReplBridgeState
+} from "./chunk-4EP3TUFF.js";
+import {
+  loadMemoryRulesFile,
+  parseMemoryRuleFrontmatter
+} from "./chunk-EORRZP3F.js";
+import {
+  createCacheFreshness
+} from "./chunk-4T5DJW54.js";
+import {
+  formatError,
+  truncateDisplay
+} from "./chunk-OMZYPQVA.js";
+
+// src/tui-state-runtime.ts
+import { spawnSync } from "child_process";
+import { readFile, readdir, stat } from "fs/promises";
+import { homedir } from "os";
+import { basename, extname, join, resolve } from "path";
+import {
+  resolveStoragePaths
+} from "@linghun/config";
+import { builtInTools } from "@linghun/tools";
+var DEFAULT_CACHE_HISTORY_SIZE = 20;
+var DEFAULT_CACHE_WARN_BELOW_HIT_RATE = 0.75;
+var PROJECT_RULES_SUMMARY_WIDTH = 600;
+function inferProviderForCacheModel(model) {
+  if (!model || model === "unknown") return "unknown";
+  if (model.startsWith("deepseek-")) return "deepseek";
+  return "unknown";
+}
+function createCacheState(projectPath, model = "unknown", mcpToolList = [], config) {
+  const freshness = createCacheFreshness({
+    systemPrompt: "Linghun interactive terminal with local extensions and workflows",
+    toolSchema: builtInTools,
+    mcpToolList: stabilizeMcpToolList(mcpToolList),
+    model,
+    provider: inferProviderForCacheModel(model),
+    projectRules: "local CLAUDE.md rules loaded by harness",
+    memory: "memory/handoff context not loaded yet",
+    compact: "not compacted",
+    plugins: []
+  });
+  return {
+    config: {
+      maxTurns: DEFAULT_CACHE_HISTORY_SIZE,
+      warnBelowHitRate: DEFAULT_CACHE_WARN_BELOW_HIT_RATE,
+      persistPath: join(resolveStoragePaths(config, projectPath).cache, "cache-log.json"),
+      hintsMuted: false
+    },
+    history: [],
+    nextTurn: 1,
+    lastFreshness: freshness,
+    hintLastShownAt: {},
+    compacted: false,
+    compactBoundaries: [],
+    compactProjection: void 0,
+    deepCompact: void 0,
+    compactPressure: void 0,
+    compactFailure: void 0,
+    compactCooldownUntil: void 0,
+    deepCompactCooldownUntil: void 0,
+    workspaceReference: createWorkspaceReferenceCache(),
+    startedAt: Date.now()
+  };
+}
+function createRemoteState(config) {
+  return {
+    enabled: config.remote.enabled,
+    channels: Object.entries(config.remote.channels).map(([id, channel]) => createRemoteChannelState(id, channel, config.remote.enabled)).sort((a, b) => a.id.localeCompare(b.id)),
+    events: [],
+    processedMessageIds: [],
+    sessionDisabledChannelIds: [],
+    pairings: [],
+    inbox: [],
+    localReplBridge: createReplBridgeState()
+  };
+}
+function createRemoteChannelState(id, config, remoteEnabled) {
+  const active = remoteEnabled && config.enabled;
+  const bindingStatus = config.bindingUserId ? "bound" : "unbound";
+  const transportStatus = active ? getRemoteTransportStatus(config) : "unknown";
+  const disabledReason = active ? void 0 : "remote_disabled";
+  const blockedReason = disabledReason ?? getRemoteBlockedReason(config, transportStatus, bindingStatus);
+  return {
+    id,
+    config,
+    runtimeStatus: blockedReason ? blockedReason === "remote_disabled" ? "disabled" : "blocked" : "ready",
+    bindingStatus,
+    transportStatus,
+    lastError: blockedReason,
+    nextAction: getRemoteNextAction(id, config, blockedReason)
+  };
+}
+function applyRemoteSessionDisables(remote) {
+  for (const channel of remote.channels) {
+    if (!remote.sessionDisabledChannelIds.includes(channel.id)) {
+      continue;
+    }
+    channel.runtimeStatus = "disabled";
+    channel.lastError = "disabled_by_user";
+    channel.nextAction = `/remote setup ${channel.id}`;
+  }
+}
+function getRemoteTransportStatus(config) {
+  if (config.transport === "webhook_mock") {
+    return "mock";
+  }
+  if (config.transport === "webhook") {
+    return config.endpoint ? "ready" : "not_configured";
+  }
+  if (!config.cliPath) {
+    return "not_configured";
+  }
+  const result = spawnSync(config.cliPath, ["--version"], { encoding: "utf8", timeout: 2e3 });
+  return result.error ? "missing" : "ready";
+}
+function getRemoteBlockedReason(config, transportStatus, bindingStatus) {
+  if (bindingStatus !== "bound") {
+    return "not_bound";
+  }
+  if (config.transport === "official_cli" && transportStatus !== "ready") {
+    return transportStatus === "missing" ? "cli_missing" : "cli_not_configured";
+  }
+  if (config.transport === "webhook" && transportStatus !== "ready") {
+    return "webhook_missing";
+  }
+  if (!config.trustedSources.length) {
+    return "source_not_trusted";
+  }
+  return void 0;
+}
+function getRemoteNextAction(channelId, config, reason) {
+  if (!reason || reason === "remote_disabled") {
+    return reason ? `/remote setup ${channelId}` : `/remote test ${channelId}`;
+  }
+  if (reason === "not_bound") {
+    return `/remote setup ${channelId}`;
+  }
+  if (reason === "cli_missing") {
+    return getRemoteInstallHint(config.type);
+  }
+  if (reason === "webhook_missing") {
+    return `configure a redacted webhook endpoint or use /remote setup ${channelId}`;
+  }
+  if (reason === "source_not_trusted") {
+    return `bind a trusted source with /remote setup ${channelId}`;
+  }
+  return "/remote doctor";
+}
+function getRemoteInstallHint(type) {
+  if (type === "feishu" || type === "lark") {
+    return "install lark-cli/feishu-cli, then run feishu-cli config init or lark-cli auth login";
+  }
+  if (type === "dingtalk") {
+    return "install dws, then run dws auth login or dws device login";
+  }
+  return "install wecom-cli, then run wecom-cli init/auth";
+}
+function createMcpState(config) {
+  const servers = Object.entries(config.mcp.servers).map(
+    ([name, server]) => ({
+      name,
+      command: server.command,
+      status: server.disabled || !config.mcp.enabledServers.includes(name) ? "disabled" : "configured"
+    })
+  ).sort((a, b) => a.name.localeCompare(b.name));
+  return {
+    enabled: config.mcp.enabledServers.length > 0,
+    servers,
+    tools: stabilizeMcpToolList(
+      servers.filter((server) => server.status === "configured").flatMap((server) => createMcpToolPlaceholders(server.name, "placeholder"))
+    )
+  };
+}
+function createMcpToolPlaceholders(serverName, discovery) {
+  if (serverName !== "codebase-memory") {
+    return [
+      {
+        server: serverName,
+        name: `${serverName}.status`,
+        description: "MCP server health and tool discovery placeholder; real tool schemas are not dumped.",
+        discovery,
+        trusted: discovery === "discovered",
+        schemaLoaded: discovery === "discovered",
+        runtimeVersion: discovery === "discovered" ? "compatible" : "unknown"
+      }
+    ];
+  }
+  return Object.keys(codebaseMemoryRequiredArgs()).map((tool) => ({
+    server: serverName,
+    name: `${serverName}.${tool}`,
+    description: `codebase-memory ${tool}; schema summary only, full schema omitted.`,
+    discovery,
+    trusted: discovery === "discovered",
+    schemaLoaded: discovery === "discovered",
+    runtimeVersion: discovery === "discovered" ? "compatible" : "unknown"
+  }));
+}
+async function createMemoryState(config, projectPath) {
+  const paths = resolveStoragePaths(config, projectPath);
+  const projectRulesPath = join(projectPath, "LINGHUN.md");
+  const projectRules = await loadProjectRulesSummary(projectRulesPath);
+  return {
+    projectRulesPath,
+    projectRulesExists: projectRules.exists,
+    projectRulesSummary: projectRules.summary,
+    ...projectRules.error ? { projectRulesError: projectRules.error } : {},
+    ...projectRules.includedPaths ? { projectRulesIncludedPaths: projectRules.includedPaths } : {},
+    ...projectRules.warnings ? { projectRulesWarnings: projectRules.warnings } : {},
+    ...projectRules.truncated ? { projectRulesTruncated: projectRules.truncated } : {},
+    projectDir: paths.memoryProject,
+    userDir: paths.memoryUser,
+    sessionDir: paths.memorySession,
+    candidates: await loadMemoryByStatus(paths, "candidate"),
+    accepted: await loadMemoryByStatus(paths, "accepted"),
+    rejected: await loadMemoryByStatus(paths, "rejected"),
+    disabled: await loadMemoryByStatus(paths, "disabled"),
+    retired: await loadMemoryByStatus(paths, "retired"),
+    ...await loadMemoryLearningMode(paths) ?? {
+      learningMode: "active",
+      learningModeSource: "default"
+    }
+  };
+}
+async function loadProjectRulesSummary(path) {
+  try {
+    const loaded = await loadMemoryRulesFile(path);
+    const parsed = parseMemoryRuleFrontmatter(loaded.content);
+    return {
+      exists: true,
+      summary: summarizeProjectRules(parsed.body),
+      includedPaths: loaded.includedPaths,
+      warnings: loaded.warnings,
+      truncated: loaded.truncated
+    };
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT") {
+      return { exists: false, summary: "missing" };
+    }
+    return { exists: false, summary: "unreadable", error: formatError(error) };
+  }
+}
+function summarizeProjectRules(content) {
+  const normalized = content.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0).join(" ").replace(/\s+/g, " ");
+  return truncateDisplay(normalized || "empty", PROJECT_RULES_SUMMARY_WIDTH);
+}
+async function loadMemoryByStatus(paths, status) {
+  const [projectMemory, userMemory] = await Promise.all([
+    loadMemoryDirByStatus(paths.memoryProject, status),
+    loadMemoryDirByStatus(paths.memoryUser, status)
+  ]);
+  return [...projectMemory, ...userMemory].sort((a, b) => a.id.localeCompare(b.id));
+}
+async function loadMemoryLearningMode(paths) {
+  try {
+    const value = JSON.parse(
+      await readFile(join(paths.memoryUser, MEMORY_LEARNING_STATE_FILE), "utf8")
+    );
+    if (!isRecord(value)) return null;
+    if (value.learningMode !== "active" && value.learningMode !== "off") return null;
+    return { learningMode: value.learningMode, learningModeSource: "persisted" };
+  } catch {
+    return null;
+  }
+}
+async function loadMemoryDirByStatus(directory, status) {
+  let entries;
+  try {
+    entries = await readdir(directory);
+  } catch {
+    return [];
+  }
+  const memory = await Promise.all(
+    entries.filter((entry) => entry.endsWith(".json")).map(async (entry) => readMemoryCandidate(join(directory, entry)))
+  );
+  return memory.filter(
+    (item) => item !== null && normalizeMemoryStatus(item) === status
+  );
+}
+async function readMemoryCandidate(path) {
+  try {
+    const value = JSON.parse(await readFile(path, "utf8"));
+    return parseMemoryCandidate(value);
+  } catch {
+    return null;
+  }
+}
+function parseMemoryCandidate(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  if (typeof value.id !== "string" || typeof value.summary !== "string" || typeof value.source !== "string" || typeof value.createdAt !== "string") {
+    return null;
+  }
+  if (value.scope !== "project" && value.scope !== "user" && value.scope !== "session") {
+    return null;
+  }
+  const taxonomy = value.taxonomy === "user" || value.taxonomy === "feedback" || value.taxonomy === "project" || value.taxonomy === "reference" ? value.taxonomy : void 0;
+  const status = value.status === "candidate" || value.status === "accepted" || value.status === "rejected" || value.status === "disabled" || value.status === "retired" ? value.status : "accepted";
+  const risk = value.risk === "medium" || value.risk === "high" ? value.risk : "low";
+  const sourceRefs = Array.isArray(value.sourceRefs) ? value.sourceRefs.filter((item) => typeof item === "string") : [value.source];
+  return {
+    id: value.id,
+    scope: value.scope,
+    status,
+    ...taxonomy ? { taxonomy } : {},
+    ...typeof value.topic === "string" && value.topic.trim().length > 0 ? { topic: truncateDisplay(value.topic.trim(), 80) } : {},
+    summary: truncateDisplay(value.summary.replace(/\s+/g, " "), 240),
+    source: value.source,
+    sourceRefs: sourceRefs.slice(0, 6),
+    risk,
+    inferred: value.inferred === true,
+    createdAt: value.createdAt
+  };
+}
+function normalizeMemoryStatus(item) {
+  return item.status ?? "accepted";
+}
+function resolveConfiguredDir(projectPath, configured) {
+  if (configured.startsWith("~/")) {
+    return join(homedir(), configured.slice(2));
+  }
+  return resolve(projectPath, configured);
+}
+async function createSkillState(config, projectPath) {
+  const projectDir = resolveConfiguredDir(projectPath, config.skills.projectDir);
+  const userDir = resolveConfiguredDir(projectPath, config.skills.userDir);
+  try {
+    const skills = await loadSkillSummaries(config, projectDir, userDir);
+    return {
+      enabled: config.skills.enabled,
+      projectDir,
+      userDir,
+      skills,
+      disabledIds: [...config.skills.disabledIds].sort((a, b) => a.localeCompare(b)),
+      trustedIds: [...config.skills.trustedIds].sort((a, b) => a.localeCompare(b)),
+      evolutionCandidates: [],
+      rejectedEvolutionCandidates: []
+    };
+  } catch (error) {
+    return {
+      enabled: config.skills.enabled,
+      projectDir,
+      userDir,
+      skills: [],
+      disabledIds: config.skills.disabledIds,
+      trustedIds: config.skills.trustedIds,
+      evolutionCandidates: [],
+      rejectedEvolutionCandidates: [],
+      lastError: formatError(error)
+    };
+  }
+}
+function createWorkflowState(config) {
+  return {
+    enabled: config.workflows.enabled,
+    disabledIds: [...config.workflows.disabledIds].sort((a, b) => a.localeCompare(b)),
+    templates: [
+      workflow("bug-fix", "\u5B9A\u4F4D bug\u3001\u505A\u6700\u5C0F\u4FEE\u590D\u3001\u8FD0\u884C\u76F8\u5173\u9A8C\u8BC1", "medium", true, [
+        "corepack pnpm test",
+        "corepack pnpm typecheck"
+      ]),
+      workflow("design-to-code", "\u628A\u5DF2\u786E\u8BA4\u8BBE\u8BA1\u8F6C\u6210\u6700\u5C0F\u4EE3\u7801\u6539\u52A8", "high", true, [
+        "corepack pnpm test",
+        "corepack pnpm build"
+      ]),
+      workflow("doc-to-code", "\u6309\u6587\u6863\u5DEE\u5F02\u8865\u9F50\u4EE3\u7801\u5165\u53E3\u548C\u9A8C\u8BC1", "medium", true, [
+        "corepack pnpm test",
+        "corepack pnpm check"
+      ]),
+      workflow("refactor-plan", "\u53EA\u8F93\u51FA\u91CD\u6784\u8BA1\u5212\u4E0E\u98CE\u9669\uFF0C\u4E0D\u76F4\u63A5\u6539\u4EE3\u7801", "medium", false, [
+        "corepack pnpm typecheck"
+      ]),
+      workflow("release-note", "\u57FA\u4E8E\u5DF2\u9A8C\u8BC1\u53D8\u66F4\u751F\u6210\u53D1\u5E03\u8BF4\u660E", "low", false, ["corepack pnpm check"]),
+      workflow("review", "\u53EA\u8BFB\u5BA1\u67E5 diff\u3001\u98CE\u9669\u548C\u9A8C\u8BC1\u8BC1\u636E", "low", false, ["corepack pnpm test"]),
+      workflow(
+        "solution-completeness-check",
+        "\u5148\u5224\u65AD single_issue/systemic_gap\u3001\u5F71\u54CD\u9762\u3001P0/P1/P2\u3001\u9636\u6BB5\u8FB9\u754C\u548C\u9A8C\u8BC1\u65B9\u5F0F",
+        "low",
+        false,
+        ["focused Solution Completeness Gate test"]
+      )
+    ].sort((a, b) => a.id.localeCompare(b.id))
+  };
+}
+function workflow(id, purpose, risk, writesFiles, recommendedValidation) {
+  return {
+    id,
+    purpose,
+    risk,
+    writesFiles,
+    recommendedValidation,
+    steps: [
+      "Start Gate\uFF1A\u542F\u52A8\u524D\u5148\u8BA9\u7528\u6237\u786E\u8BA4\u8303\u56F4\u3002",
+      "\u6267\u884C\u4E2D\u4EFB\u4F55\u5199\u6587\u4EF6\u3001Bash\u3001\u8054\u7F51\u6216\u4F9D\u8D56\u5B89\u88C5\u4ECD\u8D70\u73B0\u6709\u6743\u9650\u7BA1\u9053\u3002",
+      "\u7ED3\u675F\u524D\u63D0\u793A\u8FD0\u884C\u63A8\u8350\u9A8C\u8BC1\uFF0C\u5E76\u8F93\u51FA\u4FEE\u6539\u6587\u4EF6\u3001\u9A8C\u8BC1\u7ED3\u679C\u3001\u5DF2\u77E5\u9650\u5236\u548C\u8303\u56F4\u8FB9\u754C\u3002"
+    ]
+  };
+}
+async function createHookState(config, projectPath) {
+  const hooks = await loadHookSummaries(config, projectPath);
+  return {
+    enabled: config.hooks.enabled,
+    projectTrusted: config.hooks.projectTrusted,
+    timeoutMs: config.hooks.timeoutMs,
+    outputLimitBytes: config.hooks.outputLimitBytes,
+    hooks,
+    recentErrors: hooks.flatMap(
+      (hook) => hook.lastError ? [`${hook.id}: ${hook.lastError}`] : []
+    )
+  };
+}
+async function createPluginState(config, projectPath) {
+  const projectDir = resolveConfiguredDir(projectPath, config.plugins.projectDir);
+  const userDir = resolveConfiguredDir(projectPath, config.plugins.userDir);
+  try {
+    const plugins = await loadPluginSummaries(config, projectDir, userDir);
+    return {
+      enabled: config.plugins.enabled,
+      projectDir,
+      userDir,
+      plugins,
+      disabledIds: [...config.plugins.disabledIds].sort((a, b) => a.localeCompare(b)),
+      trustedIds: [...config.plugins.trustedIds].sort((a, b) => a.localeCompare(b))
+    };
+  } catch (error) {
+    return {
+      enabled: config.plugins.enabled,
+      projectDir,
+      userDir,
+      plugins: [],
+      disabledIds: config.plugins.disabledIds,
+      trustedIds: config.plugins.trustedIds,
+      lastError: formatError(error)
+    };
+  }
+}
+async function loadSkillSummaries(config, projectDir, userDir) {
+  const loaded = await Promise.all([
+    loadSkillDir(config, projectDir, "project"),
+    loadSkillDir(config, userDir, "user")
+  ]);
+  return loaded.flat().sort((a, b) => a.id.localeCompare(b.id));
+}
+async function loadSkillDir(config, directory, scope) {
+  const entries = await readJsonManifestFiles(directory);
+  const items = await Promise.all(entries.map((path) => readSkillManifest(config, path, scope)));
+  return items.filter((item) => item !== null);
+}
+async function readSkillManifest(config, path, scope) {
+  try {
+    const value = JSON.parse(await readFile(path, "utf8"));
+    const id = stableId(value.id, basename(path, extname(path)));
+    const permissions = stringArray(value.permissions).sort((a, b) => a.localeCompare(b));
+    const source = parseSource(value.source, scope);
+    const trusted = source === "official" || config.skills.trustedIds.includes(id);
+    const enabled = config.skills.enabled && !config.skills.disabledIds.includes(id) && trusted;
+    return {
+      id,
+      name: stringValue(value.name, id),
+      description: truncateDisplay(stringValue(value.description, "no description"), 240),
+      triggers: stringArray(value.triggers).sort((a, b) => a.localeCompare(b)),
+      summary: truncateDisplay(stringValue(value.summary, stringValue(value.description, "")), 600),
+      source,
+      scope,
+      path,
+      version: stringValue(value.version, "0.0.0"),
+      enabled,
+      trusted,
+      permissions,
+      mayWrite: permissions.includes("write"),
+      mayExecute: permissions.includes("bash") || permissions.includes("execute"),
+      mayNetwork: permissions.includes("network"),
+      lifecycle: readLifecycleRecord(value, {
+        path,
+        source,
+        trusted,
+        enabled,
+        permissions,
+        hasSchema: true
+      })
+    };
+  } catch (error) {
+    return {
+      id: basename(path, extname(path)),
+      name: basename(path),
+      description: "manifest load failed; skill isolated from main session",
+      triggers: [],
+      summary: "manifest load failed; skill isolated from prompt and tools",
+      source: scope === "project" ? "third-party" : "local",
+      scope,
+      path,
+      version: "unknown",
+      enabled: false,
+      trusted: false,
+      permissions: [],
+      mayWrite: false,
+      mayExecute: false,
+      mayNetwork: false,
+      lifecycle: {
+        localPath: path,
+        trustLevel: "disabled",
+        permissionSummary: "none",
+        discovered: false,
+        registered: false,
+        schemaLoaded: false,
+        runtimeVersion: "unknown"
+      },
+      lastError: formatError(error)
+    };
+  }
+}
+async function loadPluginSummaries(config, projectDir, userDir) {
+  const loaded = await Promise.all([
+    loadPluginDir(config, projectDir, "project"),
+    loadPluginDir(config, userDir, "user")
+  ]);
+  return loaded.flat().sort((a, b) => a.id.localeCompare(b.id));
+}
+async function loadPluginDir(config, directory, scope) {
+  const entries = await readJsonManifestFiles(directory);
+  const items = await Promise.all(entries.map((path) => readPluginManifest(config, path, scope)));
+  return items.filter((item) => item !== null);
+}
+async function readPluginManifest(config, path, scope) {
+  try {
+    const value = JSON.parse(await readFile(path, "utf8"));
+    const id = stableId(value.id, basename(path, extname(path)));
+    const permissions = stringArray(value.permissions).sort((a, b) => a.localeCompare(b));
+    const source = parseSource(value.source, scope);
+    const trusted = source === "official" || config.plugins.trustedIds.includes(id);
+    const enabled = config.plugins.enabled && !config.plugins.disabledIds.includes(id) && trusted;
+    const contributions = normalizeContributions(value.contributions);
+    return {
+      id,
+      name: stringValue(value.name, id),
+      version: stringValue(value.version, "0.0.0"),
+      description: truncateDisplay(stringValue(value.description, "no description"), 240),
+      source,
+      scope,
+      path,
+      enabled,
+      trusted,
+      permissions,
+      mayWrite: permissions.includes("write"),
+      mayExecute: permissions.includes("bash") || permissions.includes("execute"),
+      mayNetwork: permissions.includes("network"),
+      lifecycle: readLifecycleRecord(value, {
+        path,
+        source,
+        trusted,
+        enabled,
+        permissions,
+        hasSchema: Object.values(contributions).some((items) => items.length > 0)
+      }),
+      contributions
+    };
+  } catch (error) {
+    return {
+      id: basename(path, extname(path)),
+      name: basename(path),
+      version: "unknown",
+      description: "manifest load failed; plugin isolated from main session",
+      source: scope === "project" ? "third-party" : "local",
+      scope,
+      path,
+      enabled: false,
+      trusted: false,
+      permissions: [],
+      mayWrite: false,
+      mayExecute: false,
+      mayNetwork: false,
+      lifecycle: {
+        localPath: path,
+        trustLevel: "disabled",
+        permissionSummary: "none",
+        discovered: false,
+        registered: false,
+        schemaLoaded: false,
+        runtimeVersion: "unknown"
+      },
+      contributions: normalizeContributions(void 0),
+      lastError: formatError(error)
+    };
+  }
+}
+async function loadHookSummaries(config, projectPath) {
+  const pluginHooks = (await createPluginState(config, projectPath)).plugins.flatMap(
+    (plugin) => plugin.contributions.hooks.map((event) => ({ plugin, event }))
+  );
+  return pluginHooks.map(({ plugin, event }) => ({
+    id: `${plugin.id}:${event}`,
+    event: parseHookEvent(event),
+    source: plugin.source,
+    scope: plugin.scope,
+    path: plugin.path,
+    enabled: config.hooks.enabled && plugin.enabled && plugin.trusted && (plugin.scope !== "project" || config.hooks.projectTrusted),
+    trusted: plugin.trusted && (plugin.scope !== "project" || config.hooks.projectTrusted),
+    timeoutMs: config.hooks.timeoutMs,
+    outputLimitBytes: config.hooks.outputLimitBytes,
+    permissions: plugin.permissions,
+    logPath: join(projectPath, ".linghun", "logs", "hooks", `${plugin.id}.log`),
+    lastError: plugin.lastError
+  })).sort((a, b) => `${a.event}:${a.id}`.localeCompare(`${b.event}:${b.id}`));
+}
+function parseHookEvent(value) {
+  const allowed = [
+    "Notification",
+    "Plugin",
+    "PostToolUse",
+    "PreToolUse",
+    "Stop",
+    "Workflow"
+  ];
+  return allowed.includes(value) ? value : "Plugin";
+}
+async function readJsonManifestFiles(directory) {
+  let entries;
+  try {
+    entries = await readdir(directory);
+  } catch {
+    return [];
+  }
+  return entries.filter((entry) => entry.endsWith(".json")).map((entry) => join(directory, entry)).sort((a, b) => a.localeCompare(b));
+}
+function normalizeContributions(value) {
+  const input = isRecord(value) ? value : {};
+  return {
+    commands: stringArray(input.commands).sort((a, b) => a.localeCompare(b)),
+    hooks: stringArray(input.hooks).sort((a, b) => a.localeCompare(b)),
+    mcpServers: stringArray(input.mcpServers).sort((a, b) => a.localeCompare(b)),
+    providers: stringArray(input.providers).sort((a, b) => a.localeCompare(b)),
+    skills: stringArray(input.skills).sort((a, b) => a.localeCompare(b)),
+    workflows: stringArray(input.workflows).sort((a, b) => a.localeCompare(b))
+  };
+}
+function parseSource(value, scope) {
+  if (value === "official" || value === "third-party" || value === "local") {
+    return value;
+  }
+  return scope === "project" ? "third-party" : "local";
+}
+function stableId(value, fallback) {
+  return stringValue(value, fallback).trim().toLowerCase().replace(/[^a-z0-9_.-]+/g, "-");
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function stringValue(value, fallback) {
+  return typeof value === "string" && value.length > 0 ? value : fallback;
+}
+function permissionSummary(permissions) {
+  if (permissions.length === 0) {
+    return "none";
+  }
+  const risks = [
+    permissions.includes("write") ? "write" : void 0,
+    permissions.includes("bash") || permissions.includes("execute") ? "execute" : void 0,
+    permissions.includes("network") ? "network" : void 0
+  ].filter((item) => Boolean(item));
+  return risks.length > 0 ? risks.join("+") : permissions.join("+");
+}
+function readLifecycleRecord(value, options) {
+  const raw = isRecord(value.lifecycle) ? value.lifecycle : value;
+  return {
+    sourceUrl: typeof raw.sourceUrl === "string" ? raw.sourceUrl : void 0,
+    localPath: typeof raw.localPath === "string" ? raw.localPath : options.path,
+    ref: typeof raw.ref === "string" ? raw.ref : void 0,
+    commit: typeof raw.commit === "string" ? raw.commit : void 0,
+    installedAt: typeof raw.installedAt === "string" ? raw.installedAt : void 0,
+    trustLevel: options.enabled ? "trusted" : options.trusted ? "disabled" : "untrusted",
+    permissionSummary: permissionSummary(options.permissions),
+    discovered: true,
+    registered: true,
+    schemaLoaded: options.hasSchema,
+    runtimeVersion: "compatible"
+  };
+}
+async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function codebaseMemoryRequiredArgs() {
+  return {
+    list_projects: [],
+    index_status: ["project"],
+    detect_changes: ["project"],
+    index_repository: ["repo_path"],
+    search_code: ["project", "pattern"],
+    get_architecture: ["project"],
+    get_code_snippet: ["project", "qualified_name"],
+    query_graph: ["project", "query"],
+    trace_path: ["project", "from", "to"],
+    search_graph: ["project", "query"]
+  };
+}
+function stabilizeMcpToolList(tools) {
+  return tools.map((tool) => ({
+    server: tool.server,
+    name: tool.name,
+    description: truncateDisplay(tool.description.replace(/\s+/g, " "), 120),
+    discovery: tool.discovery ?? "placeholder",
+    trusted: tool.trusted ?? false,
+    schemaLoaded: tool.schemaLoaded ?? false,
+    runtimeVersion: tool.runtimeVersion ?? "unknown"
+  })).sort((a, b) => `${a.server}:${a.name}`.localeCompare(`${b.server}:${b.name}`));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export {
+  createCacheState,
+  createRemoteState,
+  applyRemoteSessionDisables,
+  getRemoteInstallHint,
+  createMcpState,
+  createMcpToolPlaceholders,
+  createMemoryState,
+  summarizeProjectRules,
+  normalizeMemoryStatus,
+  createSkillState,
+  createWorkflowState,
+  createHookState,
+  createPluginState,
+  stableId,
+  pathExists,
+  codebaseMemoryRequiredArgs,
+  stabilizeMcpToolList,
+  isRecord
+};