@lyy0709/contextweaver 1.0.0

package/dist/chunk-YVLGQTLG.js

@@ -0,0 +1,170 @@
+import {
+  isDev,
+  isMcpMode
+} from "./chunk-V2USKRIC.js";
+
+// src/utils/logger.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { Writable } from "stream";
+import pino from "pino";
+var logLevel = isDev ? "debug" : "info";
+var logDir = path.join(os.homedir(), ".contextweaver", "logs");
+var LOG_RETENTION_DAYS = 7;
+function ensureLogDir(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+function getLogFileName() {
+  const now = /* @__PURE__ */ new Date();
+  const dateStr = now.toISOString().split("T")[0];
+  return `app.${dateStr}.log`;
+}
+function formatTime() {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (n) => n.toString().padStart(2, "0");
+  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}`;
+}
+function getLevelLabel(level) {
+  const labels = {
+    10: "TRACE",
+    20: "DEBUG",
+    30: "INFO",
+    40: "WARN",
+    50: "ERROR",
+    60: "FATAL"
+  };
+  return labels[level] || "INFO";
+}
+function cleanupOldLogs(dir) {
+  try {
+    if (!fs.existsSync(dir)) return;
+    const files = fs.readdirSync(dir);
+    const now = Date.now();
+    const maxAge = LOG_RETENTION_DAYS * 24 * 60 * 60 * 1e3;
+    const logPattern = /^app\.(\d{4}-\d{2}-\d{2})\.log$/;
+    for (const file of files) {
+      const match = file.match(logPattern);
+      if (!match) continue;
+      const dateStr = match[1];
+      const fileDate = new Date(dateStr).getTime();
+      if (Number.isNaN(fileDate)) continue;
+      if (now - fileDate > maxAge) {
+        const filePath = path.join(dir, file);
+        try {
+          fs.unlinkSync(filePath);
+          console.error(`[Logger] \u6E05\u7406\u8FC7\u671F\u65E5\u5FD7: ${file}`);
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
+function createFormattedStream(filePath) {
+  const writeStream = fs.createWriteStream(filePath, { flags: "a" });
+  return new Writable({
+    write(chunk, _encoding, callback) {
+      try {
+        const log = JSON.parse(chunk.toString());
+        const time = formatTime();
+        const level = getLevelLabel(log.level);
+        const msg = log.msg || "";
+        const { level: _l, time: _t, pid: _p, hostname: _h, name: _n, msg: _m, ...extra } = log;
+        let line = `${time} [${level}] ${msg}`;
+        if (Object.keys(extra).length > 0) {
+          line += ` ${JSON.stringify(extra)}`;
+        }
+        writeStream.write(`${line}
+`, callback);
+      } catch {
+        writeStream.write(chunk.toString(), callback);
+      }
+    }
+  });
+}
+function createConsoleStream() {
+  const colors = {
+    10: "\x1B[90m",
+    // TRACE - 灰色
+    20: "\x1B[36m",
+    // DEBUG - 青色
+    30: "\x1B[32m",
+    // INFO - 绿色
+    40: "\x1B[33m",
+    // WARN - 黄色
+    50: "\x1B[31m",
+    // ERROR - 红色
+    60: "\x1B[35m"
+    // FATAL - 品红
+  };
+  const reset = "\x1B[0m";
+  return new Writable({
+    write(chunk, _encoding, callback) {
+      try {
+        const log = JSON.parse(chunk.toString());
+        const time = formatTime();
+        const level = getLevelLabel(log.level);
+        const color = colors[log.level] || "";
+        const msg = log.msg || "";
+        const { level: _l, time: _t, pid: _p, hostname: _h, name: _n, msg: _m, ...extra } = log;
+        let line = `${color}${time} [${level}]${reset} ${msg}`;
+        if (Object.keys(extra).length > 0) {
+          const extraStr = JSON.stringify(extra);
+          line += ` ${color}${extraStr}${reset}`;
+        }
+        process.stdout.write(`${line}
+`, callback);
+      } catch {
+        process.stdout.write(chunk.toString(), callback);
+      }
+    }
+  });
+}
+function createDevLogger() {
+  ensureLogDir(logDir);
+  cleanupOldLogs(logDir);
+  const logPath = path.join(logDir, getLogFileName());
+  const logStream = createFormattedStream(logPath);
+  const consoleStream = createConsoleStream();
+  return pino(
+    {
+      level: logLevel,
+      name: "contextweaver"
+    },
+    // MCP 模式下禁用控制台输出，避免污染 STDIO 协议流
+    isMcpMode ? logStream : pino.multistream([
+      { stream: logStream, level: logLevel },
+      { stream: consoleStream, level: logLevel }
+    ])
+  );
+}
+function createProdLogger() {
+  ensureLogDir(logDir);
+  cleanupOldLogs(logDir);
+  const logPath = path.join(logDir, getLogFileName());
+  const logStream = createFormattedStream(logPath);
+  const consoleStream = createConsoleStream();
+  return pino(
+    {
+      level: logLevel,
+      name: "contextweaver"
+    },
+    // MCP 模式下禁用控制台输出，避免污染 STDIO 协议流
+    isMcpMode ? logStream : pino.multistream([
+      { stream: logStream, level: logLevel },
+      { stream: consoleStream, level: logLevel }
+    ])
+  );
+}
+var logger = isDev ? createDevLogger() : createProdLogger();
+function isDebugEnabled() {
+  return logger.isLevelEnabled("debug");
+}
+
+export {
+  logger,
+  isDebugEnabled
+};

package/dist/claude-IKIA62JA.js

@@ -0,0 +1,42 @@
+// src/enhancer/adapters/claude.ts
+var ClaudeAdapter = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async chat(messages) {
+    const system = messages.filter((m) => m.role === "system").map((m) => m.content).join("\n");
+    const userAssistantMessages = messages.filter((m) => m.role !== "system").map((m) => ({
+      role: m.role === "assistant" ? "assistant" : "user",
+      content: [{ type: "text", text: m.content }]
+    }));
+    const response = await fetch(this.config.baseUrl, {
+      method: "POST",
+      headers: {
+        "x-api-key": this.config.apiKey,
+        "anthropic-version": "2023-06-01",
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: this.config.model,
+        system,
+        messages: userAssistantMessages,
+        max_tokens: 4096,
+        temperature: 0.7
+      })
+    });
+    const data = await response.json();
+    if (!response.ok || data.error) {
+      const errorMsg = data.error?.message || `HTTP ${response.status}`;
+      throw new Error(`Claude API \u9519\u8BEF: ${errorMsg}`);
+    }
+    const content = data.content?.[0]?.text;
+    if (!content) {
+      throw new Error("Claude API \u8FD4\u56DE\u4E3A\u7A7A");
+    }
+    return content;
+  }
+};
+export {
+  ClaudeAdapter
+};

package/dist/codebaseRetrieval-SCN3YIPM.js

@@ -0,0 +1,11 @@
+import {
+  codebaseRetrievalSchema,
+  handleCodebaseRetrieval
+} from "./chunk-XVKMTPCT.js";
+import "./chunk-LPFRFKFW.js";
+import "./chunk-YVLGQTLG.js";
+import "./chunk-V2USKRIC.js";
+export {
+  codebaseRetrievalSchema,
+  handleCodebaseRetrieval
+};

package/dist/config-WTC56Y2R.js

@@ -0,0 +1,22 @@
+import {
+  checkEmbeddingEnv,
+  checkEnhancerEnv,
+  checkRerankerEnv,
+  getEmbeddingConfig,
+  getEnhancerConfig,
+  getExcludePatterns,
+  getRerankerConfig,
+  isDev,
+  isMcpMode
+} from "./chunk-V2USKRIC.js";
+export {
+  checkEmbeddingEnv,
+  checkEnhancerEnv,
+  checkRerankerEnv,
+  getEmbeddingConfig,
+  getEnhancerConfig,
+  getExcludePatterns,
+  getRerankerConfig,
+  isDev,
+  isMcpMode
+};

package/dist/enhancer-QHNMR35J.js

@@ -0,0 +1,8 @@
+import {
+  enhancePrompt
+} from "./chunk-6HF343R7.js";
+import "./chunk-YVLGQTLG.js";
+import "./chunk-V2USKRIC.js";
+export {
+  enhancePrompt
+};

package/dist/gemini-Q37K5XA5.js

@@ -0,0 +1,44 @@
+// src/enhancer/adapters/gemini.ts
+var GeminiAdapter = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async chat(messages) {
+    const systemInstruction = messages.filter((m) => m.role === "system").map((m) => m.content).join("\n");
+    const contents = messages.filter((m) => m.role !== "system").map((m) => ({
+      role: m.role === "assistant" ? "model" : "user",
+      parts: [{ text: m.content }]
+    }));
+    const baseUrl = this.config.baseUrl.replace(/\/+$/, "");
+    const withoutVersion = baseUrl.replace(/\/v1beta$/, "");
+    const url = `${withoutVersion}/v1beta/models/${encodeURIComponent(this.config.model)}:generateContent?key=${encodeURIComponent(this.config.apiKey)}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        // Gemini accepts systemInstruction at top-level.
+        systemInstruction: systemInstruction ? { parts: [{ text: systemInstruction }] } : void 0,
+        contents,
+        generationConfig: {
+          temperature: 0.7
+        }
+      })
+    });
+    const data = await response.json();
+    if (!response.ok || data.error) {
+      const errorMsg = data.error?.message || `HTTP ${response.status}`;
+      throw new Error(`Gemini API \u9519\u8BEF: ${errorMsg}`);
+    }
+    const content = data.candidates?.[0]?.content?.parts?.[0]?.text;
+    if (!content) {
+      throw new Error("Gemini API \u8FD4\u56DE\u4E3A\u7A7A");
+    }
+    return content;
+  }
+};
+export {
+  GeminiAdapter
+};

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+import {
+  scan
+} from "./chunk-CKN7LWEA.js";
+import "./chunk-ECEVTSSZ.js";
+import {
+  generateProjectId
+} from "./chunk-LPFRFKFW.js";
+import {
+  logger
+} from "./chunk-YVLGQTLG.js";
+import "./chunk-V2USKRIC.js";
+
+// src/index.ts
+import { promises as fs } from "fs";
+import os from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+import cac from "cac";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var pkgPath = path.resolve(__dirname, "../package.json");
+var pkg = JSON.parse(await fs.readFile(pkgPath, "utf-8"));
+var cli = cac("contextweaver");
+if (process.argv.includes("-v") || process.argv.includes("--version")) {
+  console.log(pkg.version);
+  process.exit(0);
+}
+cli.command("init", "\u521D\u59CB\u5316 ContextWeaver \u914D\u7F6E").action(async () => {
+  const configDir = path.join(os.homedir(), ".contextweaver");
+  const envFile = path.join(configDir, ".env");
+  logger.info("\u5F00\u59CB\u521D\u59CB\u5316 ContextWeaver...");
+  try {
+    await fs.mkdir(configDir, { recursive: true });
+    logger.info(`\u521B\u5EFA\u914D\u7F6E\u76EE\u5F55: ${configDir}`);
+  } catch (err) {
+    const error = err;
+    if (error.code !== "EEXIST") {
+      logger.error({ err, stack: error.stack }, `\u521B\u5EFA\u914D\u7F6E\u76EE\u5F55\u5931\u8D25: ${error.message}`);
+      process.exit(1);
+    }
+    logger.info(`\u914D\u7F6E\u76EE\u5F55\u5DF2\u5B58\u5728: ${configDir}`);
+  }
+  try {
+    await fs.access(envFile);
+    logger.warn(`.env \u6587\u4EF6\u5DF2\u5B58\u5728: ${envFile}`);
+    logger.info("\u521D\u59CB\u5316\u5B8C\u6210\uFF01");
+    return;
+  } catch {
+  }
+  const defaultEnvContent = `# ContextWeaver \u793A\u4F8B\u73AF\u5883\u53D8\u91CF\u914D\u7F6E\u6587\u4EF6
+
+# Embedding API \u914D\u7F6E\uFF08\u5FC5\u9700\uFF09
+EMBEDDINGS_API_KEY=your-api-key-here
+EMBEDDINGS_BASE_URL=https://api.siliconflow.cn/v1/embeddings
+EMBEDDINGS_MODEL=BAAI/bge-m3
+EMBEDDINGS_MAX_CONCURRENCY=10
+EMBEDDINGS_DIMENSIONS=1024
+
+# Reranker \u914D\u7F6E\uFF08\u5FC5\u9700\uFF09
+RERANK_API_KEY=your-api-key-here
+RERANK_BASE_URL=https://api.siliconflow.cn/v1/rerank
+RERANK_MODEL=BAAI/bge-reranker-v2-m3
+RERANK_TOP_N=20
+
+# \u7D22\u5F15\u5FFD\u7565\u6A21\u5F0F\uFF08\u53EF\u9009\uFF0C\u9017\u53F7\u5206\u9694\uFF0C\u9ED8\u8BA4\u5DF2\u5305\u542B\u5E38\u89C1\u5FFD\u7565\u9879\uFF09
+# IGNORE_PATTERNS=.venv,node_modules
+
+# Prompt Enhancer \u914D\u7F6E\uFF08\u53EF\u9009\uFF0C\u4F7F\u7528 enhance \u547D\u4EE4\u65F6\u9700\u8981\uFF09
+# PROMPT_ENHANCER_ENDPOINT=openai
+# PROMPT_ENHANCER_BASE_URL=
+# PROMPT_ENHANCER_TOKEN=your-api-key-here
+# PROMPT_ENHANCER_MODEL=
+# PROMPT_ENHANCER_TEMPLATE=
+`;
+  try {
+    await fs.writeFile(envFile, defaultEnvContent);
+    logger.info(`\u521B\u5EFA .env \u6587\u4EF6: ${envFile}`);
+  } catch (err) {
+    const error = err;
+    logger.error({ err, stack: error.stack }, `\u521B\u5EFA .env \u6587\u4EF6\u5931\u8D25: ${error.message}`);
+    process.exit(1);
+  }
+  logger.info("\u4E0B\u4E00\u6B65\u64CD\u4F5C:");
+  logger.info(`   1. \u7F16\u8F91\u914D\u7F6E\u6587\u4EF6: ${envFile}`);
+  logger.info("   2. \u586B\u5199\u4F60\u7684 API Key \u548C\u5176\u4ED6\u914D\u7F6E");
+  logger.info("\u521D\u59CB\u5316\u5B8C\u6210\uFF01");
+});
+cli.command("index [path]", "\u626B\u63CF\u4EE3\u7801\u5E93\u5E76\u5EFA\u7ACB\u7D22\u5F15").option("-f, --force", "\u5F3A\u5236\u91CD\u65B0\u7D22\u5F15").action(async (targetPath, options) => {
+  const rootPath = targetPath ? path.resolve(targetPath) : process.cwd();
+  const projectId = generateProjectId(rootPath);
+  logger.info(`\u5F00\u59CB\u626B\u63CF: ${rootPath}`);
+  logger.info(`\u9879\u76EE ID: ${projectId}`);
+  if (options.force) {
+    logger.info("\u5F3A\u5236\u91CD\u65B0\u7D22\u5F15: \u662F");
+  }
+  const startTime = Date.now();
+  try {
+    let lastLoggedPercent = 0;
+    const stats = await scan(rootPath, {
+      force: options.force,
+      onProgress: (current, total, message) => {
+        if (total !== void 0) {
+          const percent = Math.floor(current / total * 100);
+          if (percent >= lastLoggedPercent + 30 && percent < 100) {
+            logger.info(`\u7D22\u5F15\u8FDB\u5EA6: ${percent}% - ${message || ""}`);
+            lastLoggedPercent = Math.floor(percent / 30) * 30;
+          }
+        }
+      }
+    });
+    process.stdout.write("\n");
+    const duration = ((Date.now() - startTime) / 1e3).toFixed(2);
+    logger.info(`\u7D22\u5F15\u5B8C\u6210 (${duration}s)`);
+    logger.info(
+      `\u603B\u6570:${stats.totalFiles} \u65B0\u589E:${stats.added} \u4FEE\u6539:${stats.modified} \u672A\u53D8:${stats.unchanged} \u5220\u9664:${stats.deleted} \u8DF3\u8FC7:${stats.skipped} \u9519\u8BEF:${stats.errors}`
+    );
+  } catch (err) {
+    const error = err;
+    logger.error({ err, stack: error.stack }, `\u7D22\u5F15\u5931\u8D25: ${error.message}`);
+    process.exit(1);
+  }
+});
+cli.command("mcp", "\u542F\u52A8 MCP \u670D\u52A1\u5668").action(async () => {
+  const { startMcpServer } = await import("./server-DENFYPME.js");
+  try {
+    await startMcpServer();
+  } catch (err) {
+    const error = err;
+    logger.error(
+      { error: error.message, stack: error.stack },
+      `MCP \u670D\u52A1\u5668\u542F\u52A8\u5931\u8D25: ${error.message}`
+    );
+    process.exit(1);
+  }
+});
+cli.command("enhance <prompt>", "\u589E\u5F3A\u63D0\u793A\u8BCD").option("--no-browser", "\u76F4\u63A5\u8F93\u51FA\u5230\u7EC8\u7AEF\uFF0C\u4E0D\u542F\u52A8\u6D4F\u89C8\u5668").option("--endpoint <type>", "\u6307\u5B9A API \u7AEF\u70B9 (openai/claude/gemini)").action(
+  async (prompt, options) => {
+    const endpointRaw = options.endpoint?.toLowerCase();
+    const endpointOverride = endpointRaw === "openai" || endpointRaw === "claude" || endpointRaw === "gemini" ? endpointRaw : void 0;
+    if (options.browser === false) {
+      const { enhancePrompt } = await import("./enhancer-QHNMR35J.js");
+      try {
+        const result = await enhancePrompt({ prompt, endpointOverride });
+        process.stdout.write(`${result.enhanced}
+`);
+      } catch (err) {
+        const error = err;
+        logger.error(
+          { error: error.message, stack: error.stack },
+          `enhance \u5931\u8D25: ${error.message}`
+        );
+        process.exit(1);
+      }
+      return;
+    }
+    const { startEnhanceServer } = await import("./server-276GGS5G.js");
+    const { openBrowser } = await import("./browser-VC5772XM.js");
+    try {
+      const result = await startEnhanceServer(prompt, {
+        endpointOverride,
+        onStarted: (url) => {
+          openBrowser(url);
+        }
+      });
+      process.stdout.write(`${result.enhanced}
+`);
+    } catch (err) {
+      const error = err;
+      logger.error(
+        { error: error.message, stack: error.stack },
+        `enhance \u5931\u8D25: ${error.message}`
+      );
+      process.exit(1);
+    }
+  }
+);
+cli.command("search", "\u672C\u5730\u68C0\u7D22\uFF08\u53C2\u6570\u5BF9\u9F50 MCP\uFF09").option("--repo-path <path>", "\u4EE3\u7801\u5E93\u6839\u76EE\u5F55\uFF08\u9ED8\u8BA4\u5F53\u524D\u76EE\u5F55\uFF09").option("--information-request <text>", "\u81EA\u7136\u8BED\u8A00\u95EE\u9898\u63CF\u8FF0\uFF08\u5FC5\u586B\uFF09").option("--technical-terms <terms>", "\u7CBE\u786E\u672F\u8BED\uFF08\u9017\u53F7\u5206\u9694\uFF09").option("--zen", "\u4F7F\u7528 MCP Zen \u914D\u7F6E\uFF08\u9ED8\u8BA4\u5F00\u542F\uFF09").action(
+  async (options) => {
+    const repoPath = options.repoPath ? path.resolve(options.repoPath) : process.cwd();
+    const informationRequest = options.informationRequest;
+    if (!informationRequest) {
+      logger.error("\u7F3A\u5C11 --information-request");
+      process.exit(1);
+    }
+    const technicalTerms = (options.technicalTerms || "").split(",").map((t) => t.trim()).filter(Boolean);
+    const useZen = options.zen !== false;
+    const { handleCodebaseRetrieval } = await import("./codebaseRetrieval-SCN3YIPM.js");
+    const response = await handleCodebaseRetrieval(
+      {
+        repo_path: repoPath,
+        information_request: informationRequest,
+        technical_terms: technicalTerms.length > 0 ? technicalTerms : void 0
+      },
+      useZen ? void 0 : {}
+    );
+    const text = response.content.map((item) => item.text).join("\n");
+    process.stdout.write(`${text}
+`);
+  }
+);
+cli.help();
+cli.parse();

package/dist/lock-K4TS4ENC.js

@@ -0,0 +1,106 @@
+import {
+  logger
+} from "./chunk-YVLGQTLG.js";
+import "./chunk-V2USKRIC.js";
+
+// src/utils/lock.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var BASE_DIR = path.join(os.homedir(), ".contextweaver");
+var LOCK_TIMEOUT_MS = 5 * 60 * 1e3;
+var LOCK_CHECK_INTERVAL_MS = 100;
+function getLockFilePath(projectId) {
+  return path.join(BASE_DIR, projectId, "index.lock");
+}
+function isLockValid(lockPath) {
+  try {
+    if (!fs.existsSync(lockPath)) {
+      return false;
+    }
+    const content = fs.readFileSync(lockPath, "utf-8");
+    const lockInfo = JSON.parse(content);
+    if (Date.now() - lockInfo.timestamp > LOCK_TIMEOUT_MS) {
+      logger.warn({ lockInfo, lockPath }, "\u9501\u5DF2\u8D85\u65F6");
+      return false;
+    }
+    try {
+      process.kill(lockInfo.pid, 0);
+      return true;
+    } catch {
+      logger.warn({ pid: lockInfo.pid }, "\u6301\u6709\u9501\u7684\u8FDB\u7A0B\u5DF2\u6B7B\u4EA1");
+      return false;
+    }
+  } catch (err) {
+    const error = err;
+    logger.debug({ error: error.message }, "\u8BFB\u53D6\u9501\u6587\u4EF6\u5931\u8D25");
+    return false;
+  }
+}
+async function acquireLock(projectId, operation, timeoutMs = 3e4) {
+  const lockPath = getLockFilePath(projectId);
+  const dir = path.dirname(lockPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeoutMs) {
+    if (!isLockValid(lockPath)) {
+      try {
+        const lockInfo = {
+          pid: process.pid,
+          timestamp: Date.now(),
+          operation
+        };
+        fs.writeFileSync(lockPath, JSON.stringify(lockInfo), { flag: "w" });
+        const verifyContent = fs.readFileSync(lockPath, "utf-8");
+        const verifyInfo = JSON.parse(verifyContent);
+        if (verifyInfo.pid === process.pid) {
+          logger.debug({ projectId: projectId.slice(0, 10), operation }, "\u83B7\u53D6\u9501\u6210\u529F");
+          return true;
+        }
+      } catch (err) {
+        const error = err;
+        logger.debug({ error: error.message }, "\u83B7\u53D6\u9501\u5931\u8D25\uFF0C\u91CD\u8BD5\u4E2D...");
+      }
+    } else {
+      logger.debug({ projectId: projectId.slice(0, 10) }, "\u7B49\u5F85\u9501\u91CA\u653E...");
+    }
+    await new Promise((resolve) => setTimeout(resolve, LOCK_CHECK_INTERVAL_MS));
+  }
+  logger.warn({ projectId: projectId.slice(0, 10), timeoutMs }, "\u83B7\u53D6\u9501\u8D85\u65F6");
+  return false;
+}
+function releaseLock(projectId) {
+  const lockPath = getLockFilePath(projectId);
+  try {
+    if (!fs.existsSync(lockPath)) {
+      return;
+    }
+    const content = fs.readFileSync(lockPath, "utf-8");
+    const lockInfo = JSON.parse(content);
+    if (lockInfo.pid === process.pid) {
+      fs.unlinkSync(lockPath);
+      logger.debug({ projectId: projectId.slice(0, 10) }, "\u91CA\u653E\u9501\u6210\u529F");
+    } else {
+      logger.warn({ ownPid: process.pid, lockPid: lockInfo.pid }, "\u5C1D\u8BD5\u91CA\u653E\u975E\u81EA\u5DF1\u6301\u6709\u7684\u9501");
+    }
+  } catch (err) {
+    const error = err;
+    logger.debug({ error: error.message }, "\u91CA\u653E\u9501\u65F6\u51FA\u9519");
+  }
+}
+async function withLock(projectId, operation, fn, timeoutMs = 3e4) {
+  const acquired = await acquireLock(projectId, operation, timeoutMs);
+  if (!acquired) {
+    throw new Error(`\u65E0\u6CD5\u83B7\u53D6\u9879\u76EE\u9501 (${projectId.slice(0, 10)})\uFF0C\u5176\u4ED6\u8FDB\u7A0B\u6B63\u5728\u64CD\u4F5C\u7D22\u5F15`);
+  }
+  try {
+    return await fn();
+  } finally {
+    releaseLock(projectId);
+  }
+}
+export {
+  withLock
+};

package/dist/logger-SF6S6GVR.js

@@ -0,0 +1,9 @@
+import {
+  isDebugEnabled,
+  logger
+} from "./chunk-YVLGQTLG.js";
+import "./chunk-V2USKRIC.js";
+export {
+  isDebugEnabled,
+  logger
+};

package/dist/mcp/main.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/mcp/main.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+// src/mcp/main.ts
+if (!process.argv.includes("mcp")) {
+  process.argv.push("mcp");
+}
+var { logger } = await import("../logger-SF6S6GVR.js");
+var { startMcpServer } = await import("../server-DENFYPME.js");
+try {
+  await startMcpServer();
+} catch (err) {
+  const error = err;
+  logger.error(
+    { error: error.message, stack: error.stack },
+    `MCP \u670D\u52A1\u5668\u542F\u52A8\u5931\u8D25: ${error.message}`
+  );
+  process.exit(1);
+}

package/dist/openai-MOPZNA5I.js

@@ -0,0 +1,34 @@
+// src/enhancer/adapters/openai.ts
+var OpenAiAdapter = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  async chat(messages) {
+    const response = await fetch(this.config.baseUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.config.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: this.config.model,
+        messages,
+        temperature: 0.7
+      })
+    });
+    const data = await response.json();
+    if (!response.ok || data.error) {
+      const errorMsg = data.error?.message || `HTTP ${response.status}`;
+      throw new Error(`OpenAI API \u9519\u8BEF: ${errorMsg}`);
+    }
+    const content = data.choices?.[0]?.message?.content;
+    if (!content) {
+      throw new Error("OpenAI API \u8FD4\u56DE\u4E3A\u7A7A");
+    }
+    return content;
+  }
+};
+export {
+  OpenAiAdapter
+};

package/dist/scanner-T7MGYXQV.js

@@ -0,0 +1,10 @@
+import {
+  scan
+} from "./chunk-CKN7LWEA.js";
+import "./chunk-ECEVTSSZ.js";
+import "./chunk-LPFRFKFW.js";
+import "./chunk-YVLGQTLG.js";
+import "./chunk-V2USKRIC.js";
+export {
+  scan
+};