@linghun/tui 0.1.0

package/dist/chunk-UT2TYK2A.js

@@ -0,0 +1,148 @@
+import {
+  isRecord
+} from "./chunk-QLRTQHTR.js";
+
+// src/index-runtime.ts
+import { readFile, stat } from "fs/promises";
+import { basename, join } from "path";
+function createIndexState(config) {
+  return {
+    enabled: config.index.enabled,
+    status: config.index.enabled ? "unknown" : "disabled",
+    artifactStatus: config.index.enabled ? "unknown" : "disabled",
+    projectSelectionSource: config.index.enabled ? void 0 : "missing"
+  };
+}
+function getCodebaseMemoryArtifactDir(projectPath) {
+  return join(projectPath, ".codebase-memory");
+}
+function getCodebaseMemoryGraphPath(projectPath) {
+  return join(getCodebaseMemoryArtifactDir(projectPath), "graph.db.zst");
+}
+async function readLocalIndexArtifactState(projectPath) {
+  const artifactDir = getCodebaseMemoryArtifactDir(projectPath);
+  const graphPath = getCodebaseMemoryGraphPath(projectPath);
+  try {
+    const graphStat = await stat(graphPath);
+    if (!graphStat.isFile() || graphStat.size <= 0) {
+      return { status: "corrupt", artifactPath: graphPath, error: "graph.db.zst is empty" };
+    }
+  } catch (error) {
+    const code = typeof error === "object" && error !== null ? error.code : "";
+    if (code === "ENOENT") {
+      return { status: "missing", artifactPath: graphPath };
+    }
+    return {
+      status: "corrupt",
+      artifactPath: graphPath,
+      error: error instanceof Error ? error.message : "cannot stat graph.db.zst"
+    };
+  }
+  const metadata = await readLocalIndexArtifactMetadata(join(artifactDir, "artifact.json"));
+  if (metadata.status === "corrupt") {
+    return { ...metadata, artifactPath: graphPath };
+  }
+  return { status: "ready", artifactPath: graphPath, ...metadata };
+}
+async function readLocalIndexArtifactMetadata(artifactJsonPath) {
+  let raw;
+  try {
+    raw = await readFile(artifactJsonPath, "utf8");
+  } catch (error) {
+    const code = typeof error === "object" && error !== null ? error.code : "";
+    return code === "ENOENT" ? {} : {
+      status: "corrupt",
+      error: error instanceof Error ? error.message : "cannot read artifact.json"
+    };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return {
+      projectName: typeof parsed.project === "string" ? parsed.project : void 0,
+      nodes: typeof parsed.nodes === "number" ? parsed.nodes : void 0,
+      edges: typeof parsed.edges === "number" ? parsed.edges : void 0,
+      indexedAt: typeof parsed.indexed_at === "string" ? parsed.indexed_at : void 0
+    };
+  } catch {
+    return { status: "corrupt", error: "artifact.json is not valid JSON" };
+  }
+}
+function findCurrentIndexProject(data, projectPath) {
+  if (!isRecord(data) || !Array.isArray(data.projects)) {
+    return null;
+  }
+  const normalizedProjectPath = normalizePath(projectPath);
+  const rootPathMatch = data.projects.find((project) => {
+    if (!isRecord(project)) {
+      return false;
+    }
+    return normalizePath(String(project.root_path ?? "")) === normalizedProjectPath;
+  });
+  if (isRecord(rootPathMatch) && typeof rootPathMatch.name === "string") {
+    const rootPath2 = typeof rootPathMatch.root_path === "string" ? rootPathMatch.root_path : void 0;
+    return { name: rootPathMatch.name, rootPath: rootPath2, source: "root_path" };
+  }
+  const candidateNames = createCurrentIndexProjectNameCandidates(projectPath);
+  const nameMatches = data.projects.filter((project) => {
+    if (!isRecord(project) || typeof project.name !== "string") {
+      return false;
+    }
+    return candidateNames.has(project.name.toLowerCase());
+  });
+  if (nameMatches.length !== 1) {
+    return null;
+  }
+  const [nameMatch] = nameMatches;
+  if (!isRecord(nameMatch) || typeof nameMatch.name !== "string") {
+    return null;
+  }
+  const rootPath = typeof nameMatch.root_path === "string" ? nameMatch.root_path : void 0;
+  return { name: nameMatch.name, rootPath, source: "name-candidate" };
+}
+function createCurrentIndexProjectNameCandidates(projectPath) {
+  const normalizedPath = projectPath.replaceAll("\\", "/").replace(/\/$/, "");
+  const projectName = basename(normalizedPath);
+  const candidates = /* @__PURE__ */ new Set();
+  if (projectName) {
+    candidates.add(projectName.toLowerCase());
+  }
+  const drive = /^([A-Za-z]):\//.exec(normalizedPath)?.[1];
+  if (drive && projectName) {
+    candidates.add(`${drive}-${projectName}`.toLowerCase());
+  }
+  return candidates;
+}
+function normalizePath(path) {
+  return path.replaceAll("\\", "/").replace(/\/$/, "").toLowerCase();
+}
+function createIndexStatusSnapshot(index) {
+  return {
+    projectName: index.projectName,
+    status: index.status,
+    nodes: index.nodes,
+    edges: index.edges,
+    changedFiles: index.changedFiles,
+    staleHint: index.staleHint
+  };
+}
+function formatIndexRuntimeRef(index) {
+  const project = index.projectName ? `${index.projectName}:` : "";
+  const size = typeof index.nodes === "number" || typeof index.edges === "number" ? ` nodes ${index.nodes ?? "unknown"} edges ${index.edges ?? "unknown"}` : "";
+  const stale = index.staleHint ? ` stale ${truncateIndexRef(index.staleHint, 80)}` : "";
+  return `${project}${index.status}${size}${stale}`;
+}
+function truncateIndexRef(value, max) {
+  const compact = value.replace(/\s+/gu, " ").trim();
+  return compact.length <= max ? compact : `${compact.slice(0, Math.max(0, max - 1))}\u2026`;
+}
+
+export {
+  createIndexState,
+  getCodebaseMemoryArtifactDir,
+  getCodebaseMemoryGraphPath,
+  readLocalIndexArtifactState,
+  findCurrentIndexProject,
+  createCurrentIndexProjectNameCandidates,
+  createIndexStatusSnapshot,
+  formatIndexRuntimeRef
+};

package/dist/chunk-UT5BOJKU.js

@@ -0,0 +1,190 @@
+// src/remote-transport.ts
+import { execFile as nodeExecFile } from "child_process";
+import { createHmac } from "crypto";
+var DEFAULT_WEBHOOK_TIMEOUT_MS = 8e3;
+var DEFAULT_CLI_TIMEOUT_MS = 15e3;
+function buildFeishuWebhook(endpoint, content, signingSecret, nowMs) {
+  const payload = { msg_type: "text", content: { text: content } };
+  if (signingSecret) {
+    const timestamp = Math.floor(nowMs / 1e3);
+    const sign = createHmac("sha256", `${timestamp}
+${signingSecret}`).update("").digest("base64");
+    payload.timestamp = String(timestamp);
+    payload.sign = sign;
+  }
+  return { url: endpoint, body: JSON.stringify(payload) };
+}
+function buildDingtalkWebhook(endpoint, content, signingSecret, nowMs) {
+  const payload = { msgtype: "text", text: { content } };
+  if (!signingSecret) {
+    return { url: endpoint, body: JSON.stringify(payload) };
+  }
+  const timestamp = nowMs;
+  const raw = createHmac("sha256", signingSecret).update(`${timestamp}
+${signingSecret}`).digest("base64");
+  const sign = encodeURIComponent(raw);
+  const sep = endpoint.includes("?") ? "&" : "?";
+  return {
+    url: `${endpoint}${sep}timestamp=${timestamp}&sign=${sign}`,
+    body: JSON.stringify(payload)
+  };
+}
+function buildWecomWebhook(endpoint, content) {
+  return { url: endpoint, body: JSON.stringify({ msgtype: "text", text: { content } }) };
+}
+function buildWebhookRequest(channel, event, signingSecret, nowMs = Date.now()) {
+  const endpoint = channel.config.endpoint;
+  if (!endpoint) {
+    return { ok: false, reason: "missing_endpoint" };
+  }
+  const content = event.redactedSummary;
+  const type = channel.config.type;
+  if (channel.config.signingSecretRef && !signingSecret) {
+    return { ok: false, reason: "missing_signing_secret" };
+  }
+  if (type === "feishu" || type === "lark") {
+    return { ok: true, request: buildFeishuWebhook(endpoint, content, signingSecret, nowMs) };
+  }
+  if (type === "dingtalk") {
+    return { ok: true, request: buildDingtalkWebhook(endpoint, content, signingSecret, nowMs) };
+  }
+  return { ok: true, request: buildWecomWebhook(endpoint, content) };
+}
+function buildOfficialCliInvocation(channel, event) {
+  const cliPath = channel.config.cliPath;
+  if (!cliPath) {
+    return { ok: false, reason: "missing_cli_path" };
+  }
+  const target = channel.config.bindingUserId;
+  if (!target) {
+    return { ok: false, reason: "missing_binding" };
+  }
+  const content = event.redactedSummary;
+  const type = channel.config.type;
+  if (type === "feishu" || type === "lark") {
+    return {
+      ok: true,
+      command: cliPath,
+      args: [
+        "im",
+        "messages-send",
+        "--as",
+        "bot",
+        "--receive-id",
+        target,
+        "--msg-type",
+        "text",
+        "--text",
+        content
+      ]
+    };
+  }
+  if (type === "dingtalk") {
+    return {
+      ok: true,
+      command: cliPath,
+      args: ["im", "send-by-bot", "--user", target, "--msgtype", "text", "--text", content]
+    };
+  }
+  return {
+    ok: true,
+    command: cliPath,
+    args: ["msg", "send_message", "--to", target, "--msgtype", "text", "--text", content]
+  };
+}
+function parsePlatformErrCode(body) {
+  try {
+    const parsed = JSON.parse(body);
+    for (const value of [parsed.errcode, parsed.code, parsed.StatusCode]) {
+      if (typeof value === "number") {
+        return value;
+      }
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+async function deliverWebhook(request, fetchImpl) {
+  try {
+    const response = await fetchImpl(request.url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: request.body
+    });
+    if (response.status === 401 || response.status === 403) {
+      return { status: "failed", detail: `auth rejected (HTTP ${response.status})` };
+    }
+    if (response.status < 200 || response.status >= 300) {
+      return { status: "failed", detail: `platform rejected (HTTP ${response.status})` };
+    }
+    let bodyText = "";
+    try {
+      bodyText = await response.text();
+    } catch {
+      bodyText = "";
+    }
+    const errcode = parsePlatformErrCode(bodyText);
+    if (errcode !== void 0 && errcode !== 0) {
+      return { status: "failed", detail: `platform rejected (errcode ${errcode})` };
+    }
+    return { status: "sent", detail: "delivered redacted summary to remote channel" };
+  } catch {
+    return { status: "failed", detail: "network error reaching remote channel" };
+  }
+}
+function isCliMissing(error) {
+  const code = error?.code;
+  return code === "ENOENT";
+}
+async function deliverOfficialCli(command, args, runner, timeoutMs = DEFAULT_CLI_TIMEOUT_MS) {
+  try {
+    await runner(command, args, timeoutMs);
+    return { status: "sent", detail: "official CLI accepted the redacted send" };
+  } catch (error) {
+    if (isCliMissing(error)) {
+      return { status: "blocked", detail: "official CLI not found; install and authenticate it" };
+    }
+    return { status: "failed", detail: "official CLI rejected the send" };
+  }
+}
+var defaultFetch = async (url, init) => {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), DEFAULT_WEBHOOK_TIMEOUT_MS);
+  try {
+    const response = await fetch(url, { ...init, signal: controller.signal });
+    return { status: response.status, text: () => response.text() };
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var defaultRunCli = (command, args, timeoutMs) => new Promise((resolve, reject) => {
+  nodeExecFile(
+    command,
+    args,
+    { timeout: timeoutMs, windowsHide: true },
+    (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve({ stdout: String(stdout), stderr: String(stderr) });
+    }
+  );
+});
+function defaultRemoteTransportDeps() {
+  return {
+    fetch: defaultFetch,
+    runCli: defaultRunCli,
+    resolveSecret: (ref) => process.env[ref],
+    nowMs: () => Date.now()
+  };
+}
+
+export {
+  buildWebhookRequest,
+  buildOfficialCliInvocation,
+  deliverWebhook,
+  deliverOfficialCli,
+  defaultRemoteTransportDeps
+};