@zhanngning/hecode 0.7.0 → 1.0.0

package/dist/chunk-I4W33CWB.js

@@ -1,670 +0,0 @@
-// src/tools/read_file.ts
-import { readFile } from "fs/promises";
-var readFileTool = {
-  name: "read_file",
-  description: "Read file content. Supports offset and limit for large files.",
-  parameters: {
-    type: "object",
-    properties: {
-      file_path: { type: "string", description: "Absolute path to the file" },
-      offset: { type: "number", description: "Line number to start from (1-indexed)" },
-      limit: { type: "number", description: "Max lines to read (default 2000)" }
-    },
-    required: ["file_path"]
-  },
-  async execute(params) {
-    try {
-      const content = await readFile(params.file_path, "utf-8");
-      const lines = content.split("\n");
-      const offset = params.offset || 1;
-      const limit = params.limit || 2e3;
-      const sliced = lines.slice(offset - 1, offset - 1 + limit);
-      const numbered = sliced.map((line, i) => `${offset + i}: ${line}`).join("\n");
-      return { output: numbered };
-    } catch (e) {
-      return { output: "", error: e.message };
-    }
-  }
-};
-
-// src/tools/write_file.ts
-import { writeFile, mkdir } from "fs/promises";
-import { dirname } from "path";
-var writeFileTool = {
-  name: "write_file",
-  description: "Write content to a file. Creates parent directories if needed.",
-  parameters: {
-    type: "object",
-    properties: {
-      file_path: { type: "string", description: "Absolute path to the file" },
-      content: { type: "string", description: "Content to write" }
-    },
-    required: ["file_path", "content"]
-  },
-  async execute(params) {
-    try {
-      await mkdir(dirname(params.file_path), { recursive: true });
-      await writeFile(params.file_path, params.content, "utf-8");
-      return { output: `File written: ${params.file_path}` };
-    } catch (e) {
-      return { output: "", error: e.message };
-    }
-  }
-};
-
-// src/tools/edit_file.ts
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-var editFileTool = {
-  name: "edit_file",
-  description: "Replace exact string match in a file. Fails if old_string not found or matches multiple times.",
-  parameters: {
-    type: "object",
-    properties: {
-      file_path: { type: "string", description: "Absolute path to the file" },
-      old_string: { type: "string", description: "Exact string to replace" },
-      new_string: { type: "string", description: "Replacement string" },
-      replace_all: { type: "boolean", description: "Replace all occurrences (default false)" }
-    },
-    required: ["file_path", "old_string", "new_string"]
-  },
-  async execute(params) {
-    try {
-      const content = await readFile2(params.file_path, "utf-8");
-      const oldStr = params.old_string;
-      const newStr = params.new_string;
-      const replaceAll = params.replace_all;
-      if (!content.includes(oldStr)) {
-        return { output: "", error: `old_string not found in ${params.file_path}` };
-      }
-      let result;
-      if (replaceAll) {
-        result = content.replaceAll(oldStr, newStr);
-      } else {
-        const count = content.split(oldStr).length - 1;
-        if (count > 1) {
-          return {
-            output: "",
-            error: `Found ${count} matches for old_string. Provide more context or set replace_all=true.`
-          };
-        }
-        result = content.replace(oldStr, newStr);
-      }
-      await writeFile2(params.file_path, result, "utf-8");
-      return { output: `Edited: ${params.file_path}` };
-    } catch (e) {
-      return { output: "", error: e.message };
-    }
-  }
-};
-
-// src/tools/bash.ts
-import { exec } from "child_process";
-var bashTool = {
-  name: "bash",
-  description: "Execute a shell command. Returns stdout and stderr.",
-  parameters: {
-    type: "object",
-    properties: {
-      command: { type: "string", description: "The command to execute" },
-      timeout: { type: "number", description: "Timeout in ms (default 120000)" },
-      workdir: { type: "string", description: "Working directory" }
-    },
-    required: ["command"]
-  },
-  async execute(params) {
-    return new Promise((resolve) => {
-      const timeout = params.timeout || 12e4;
-      exec(
-        params.command,
-        {
-          timeout,
-          cwd: params.workdir || process.cwd(),
-          encoding: "utf-8"
-        },
-        (error, stdout, stderr) => {
-          if (error && error.killed) {
-            resolve({
-              output: stdout ?? "",
-              error: `Command timed out after ${timeout}ms`
-            });
-          } else if (error && !stdout && !stderr) {
-            resolve({ output: "", error: error.message });
-          } else {
-            resolve({ output: [stdout, stderr].filter(Boolean).join("\n").trim() });
-          }
-        }
-      );
-    });
-  }
-};
-
-// src/tools/glob.ts
-import { glob } from "fs/promises";
-var globTool = {
-  name: "glob",
-  description: "Find files matching a glob pattern.",
-  parameters: {
-    type: "object",
-    properties: {
-      pattern: {
-        type: "string",
-        description: "Glob pattern (e.g. '**/*.ts', 'src/**/*.test.*')"
-      },
-      path: { type: "string", description: "Directory to search in (default: cwd)" }
-    },
-    required: ["pattern"]
-  },
-  async execute(params) {
-    try {
-      const files = [];
-      for await (const f of glob(params.pattern, {
-        cwd: params.path || process.cwd()
-      })) {
-        files.push(f);
-      }
-      files.sort();
-      return { output: files.join("\n") || "No files found" };
-    } catch (e) {
-      return { output: "", error: e.message };
-    }
-  }
-};
-
-// src/tools/grep.ts
-import { readFile as readFile3, readdir } from "fs/promises";
-import { join } from "path";
-var grepTool = {
-  name: "grep",
-  description: "Search file contents using regex. Returns file paths and matching line numbers.",
-  parameters: {
-    type: "object",
-    properties: {
-      pattern: { type: "string", description: "Regex pattern to search for" },
-      path: { type: "string", description: "Directory to search in (default: cwd)" },
-      include: { type: "string", description: "File pattern to include (e.g. '*.ts')" }
-    },
-    required: ["pattern"]
-  },
-  async execute(params) {
-    try {
-      const regex = new RegExp(params.pattern, "gi");
-      const rootDir = params.path || process.cwd();
-      const includePattern = params.include;
-      const results = [];
-      async function searchDir(dir, depth) {
-        if (depth > 10 || results.length >= 200) return;
-        const entries = await readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-          if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-          const fullPath = join(dir, entry.name);
-          if (entry.isDirectory()) {
-            await searchDir(fullPath, depth + 1);
-          } else if (entry.isFile()) {
-            if (includePattern && !matchGlob(entry.name, includePattern)) continue;
-            try {
-              const content = await readFile3(fullPath, "utf-8");
-              const lines = content.split("\n");
-              for (let i = 0; i < lines.length; i++) {
-                if (regex.test(lines[i])) {
-                  results.push(`${fullPath}:${i + 1}: ${lines[i].trim()}`);
-                  if (results.length >= 200) return;
-                }
-                regex.lastIndex = 0;
-              }
-            } catch {
-            }
-          }
-        }
-      }
-      await searchDir(rootDir, 0);
-      return { output: results.join("\n") || "No matches found" };
-    } catch (e) {
-      return { output: "", error: e.message };
-    }
-  }
-};
-function matchGlob(filename, pattern) {
-  const regexStr = "^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$";
-  return new RegExp(regexStr, "i").test(filename);
-}
-
-// src/datasources/akshare.ts
-import { exec as exec2 } from "child_process";
-import { promisify } from "util";
-import path from "path";
-var execAsync = promisify(exec2);
-var AkshareDataSource = class {
-  scriptPath;
-  constructor() {
-    this.scriptPath = path.join(import.meta.dirname, "akshare_datasource.py");
-  }
-  async getStockInfo(code, market = "A") {
-    const { stdout } = await execAsync(
-      `python ${this.scriptPath} info ${code} ${market}`
-    );
-    const data = JSON.parse(stdout);
-    if (data.error) throw new Error(data.error);
-    return {
-      code,
-      name: data[0]?.name || code,
-      market,
-      date: data[0]?.date,
-      open: data[0]?.open,
-      close: data[0]?.close,
-      high: data[0]?.high,
-      low: data[0]?.low,
-      volume: data[0]?.volume,
-      amount: data[0]?.amount,
-      change_pct: data[0]?.change_pct
-    };
-  }
-  async getFinancialData(code, market = "A") {
-    const { stdout } = await execAsync(
-      `python ${this.scriptPath} financial ${code} ${market}`
-    );
-    const data = JSON.parse(stdout);
-    if (data.error) throw new Error(data.error);
-    return {
-      code,
-      price: data[0]?.price,
-      change_pct: data[0]?.change_pct,
-      volume: data[0]?.volume,
-      amount: data[0]?.amount,
-      turnover: data[0]?.turnover
-    };
-  }
-  async getStockHistory(code, market = "A", days = 30) {
-    const { stdout } = await execAsync(
-      `python ${this.scriptPath} history ${code} ${market} ${days}`
-    );
-    const data = JSON.parse(stdout);
-    if (data.error) throw new Error(data.error);
-    return data.map((item) => ({
-      date: item.date,
-      open: item.open,
-      close: item.close,
-      high: item.high,
-      low: item.low,
-      volume: item.volume,
-      change_pct: item.change_pct
-    }));
-  }
-};
-
-// src/workflow/state.ts
-function createInitialState(target) {
-  return {
-    target,
-    data: {},
-    analysis: {},
-    output: {},
-    status: "pending"
-  };
-}
-
-// src/workflow/engine.ts
-var WorkflowEngine = class {
-  nodes;
-  onStateChange;
-  constructor(config) {
-    this.nodes = config.nodes;
-    this.onStateChange = config.onStateChange;
-  }
-  async execute(target) {
-    let state = createInitialState(target);
-    for (const node of this.nodes) {
-      state = await node(state);
-      this.onStateChange?.(state);
-      if (state.status === "error") {
-        throw new Error(state.error);
-      }
-    }
-    return state;
-  }
-};
-
-// src/workflow/nodes/data-collection.ts
-async function dataCollectionNode(state, dataSource) {
-  const { code, market } = state.target;
-  try {
-    const [stockInfo, financial, history] = await Promise.all([
-      dataSource.getStockInfo(code, market),
-      dataSource.getFinancialData(code, market),
-      dataSource.getStockHistory(code, market, 30)
-    ]);
-    return {
-      ...state,
-      data: {
-        stockInfo,
-        financial,
-        history
-      },
-      status: "collecting"
-    };
-  } catch (error) {
-    return {
-      ...state,
-      status: "error",
-      error: `\u6570\u636E\u91C7\u96C6\u5931\u8D25: ${error.message}`
-    };
-  }
-}
-
-// src/workflow/nodes/analysis.ts
-function calculateMA(data, period) {
-  if (data.length < period) return void 0;
-  const slice = data.slice(-period);
-  return slice.reduce((a, b) => a + b, 0) / period;
-}
-function calculateRSI(prices, period = 14) {
-  if (prices.length < period + 1) return void 0;
-  let gains = 0;
-  let losses = 0;
-  for (let i = prices.length - period; i < prices.length; i++) {
-    const change = prices[i] - prices[i - 1];
-    if (change > 0) {
-      gains += change;
-    } else {
-      losses -= change;
-    }
-  }
-  const avgGain = gains / period;
-  const avgLoss = losses / period;
-  if (avgLoss === 0) return 100;
-  const rs = avgGain / avgLoss;
-  return 100 - 100 / (1 + rs);
-}
-async function analysisNode(state) {
-  if (state.status === "error") return state;
-  const { financial, history, stockInfo } = state.data;
-  try {
-    const prices = history?.map((h) => h.close) || [];
-    const ma5 = calculateMA(prices, 5);
-    const ma10 = calculateMA(prices, 10);
-    const ma20 = calculateMA(prices, 20);
-    const rsi = calculateRSI(prices);
-    const financialAnalysis = {
-      price: financial?.price,
-      change_pct: financial?.change_pct,
-      volume: financial?.volume,
-      amount: financial?.amount,
-      turnover: financial?.turnover
-    };
-    const trend = {
-      ma5: ma5 ? Math.round(ma5 * 100) / 100 : void 0,
-      ma10: ma10 ? Math.round(ma10 * 100) / 100 : void 0,
-      ma20: ma20 ? Math.round(ma20 * 100) / 100 : void 0,
-      rsi: rsi ? Math.round(rsi * 100) / 100 : void 0
-    };
-    let trendSignal = "\u4E2D\u6027";
-    if (ma5 && ma10 && ma20) {
-      if (ma5 > ma10 && ma10 > ma20) {
-        trendSignal = "\u4E0A\u5347\u8D8B\u52BF";
-      } else if (ma5 < ma10 && ma10 < ma20) {
-        trendSignal = "\u4E0B\u964D\u8D8B\u52BF";
-      }
-    }
-    return {
-      ...state,
-      analysis: {
-        financial: financialAnalysis,
-        trend,
-        comparison: {
-          industry: stockInfo?.industry || "\u672A\u77E5",
-          trendSignal
-        }
-      },
-      status: "analyzing"
-    };
-  } catch (error) {
-    return {
-      ...state,
-      status: "error",
-      error: `\u5206\u6790\u5931\u8D25: ${error.message}`
-    };
-  }
-}
-
-// src/workflow/nodes/report.ts
-async function reportNode(state) {
-  if (state.status === "error") return state;
-  const { target, analysis, data } = state;
-  try {
-    const report = `# ${target.company} (${target.code}) \u7814\u7A76\u62A5\u544A
-
-## \u516C\u53F8\u6982\u51B5
-- **\u80A1\u7968\u4EE3\u7801**: ${target.code}
-- **\u5E02\u573A**: ${target.market}
-- **\u884C\u4E1A**: ${analysis.comparison?.industry || "\u672A\u77E5"}
-
-## \u4EF7\u683C\u4FE1\u606F
-- **\u5F53\u524D\u4EF7\u683C**: \xA5${analysis.financial?.price || "N/A"}
-- **\u6DA8\u8DCC\u5E45**: ${analysis.financial?.change_pct || "N/A"}%
-- **\u6210\u4EA4\u91CF**: ${analysis.financial?.volume ? (analysis.financial.volume / 1e4).toFixed(2) + "\u4E07\u624B" : "N/A"}
-- **\u6210\u4EA4\u989D**: ${analysis.financial?.amount ? (analysis.financial.amount / 1e8).toFixed(2) + "\u4EBF" : "N/A"}
-
-## \u6280\u672F\u5206\u6790
-- **5\u65E5\u5747\u7EBF**: \xA5${analysis.trend?.ma5 || "N/A"}
-- **10\u65E5\u5747\u7EBF**: \xA5${analysis.trend?.ma10 || "N/A"}
-- **20\u65E5\u5747\u7EBF**: \xA5${analysis.trend?.ma20 || "N/A"}
-- **RSI(14)**: ${analysis.trend?.rsi || "N/A"}
-- **\u8D8B\u52BF\u4FE1\u53F7**: ${analysis.comparison?.trendSignal || "\u4E2D\u6027"}
-
-## \u8FD1\u671F\u8D70\u52BF
-${data.history ? data.history.slice(-5).map(
-      (h) => `- ${h.date}: \u5F00\u76D8 \xA5${h.open} | \u6536\u76D8 \xA5${h.close} | \u6DA8\u8DCC ${h.change_pct}%`
-    ).join("\n") : "\u65E0\u6570\u636E"}
-
-## \u6295\u8D44\u5EFA\u8BAE
-\u57FA\u4E8E\u6280\u672F\u5206\u6790\uFF0C${target.company} \u5F53\u524D\u5904\u4E8E **${analysis.comparison?.trendSignal || "\u4E2D\u6027"}**\u3002
-
-${analysis.trend?.rsi && analysis.trend.rsi > 70 ? "\u26A0\uFE0F RSI \u8D85\u4E70\u533A\u57DF\uFF0C\u6CE8\u610F\u56DE\u8C03\u98CE\u9669" : ""}
-${analysis.trend?.rsi && analysis.trend.rsi < 30 ? "\u2705 RSI \u8D85\u5356\u533A\u57DF\uFF0C\u53EF\u80FD\u5B58\u5728\u53CD\u5F39\u673A\u4F1A" : ""}
-
----
-*\u62A5\u544A\u751F\u6210\u65F6\u95F4: ${(/* @__PURE__ */ new Date()).toISOString()}*
-*\u6570\u636E\u6765\u6E90: akshare (\u514D\u8D39\u6570\u636E)*
-`;
-    return {
-      ...state,
-      output: {
-        report,
-        format: "markdown"
-      },
-      status: "done"
-    };
-  } catch (error) {
-    return {
-      ...state,
-      status: "error",
-      error: `\u62A5\u544A\u751F\u6210\u5931\u8D25: ${error.message}`
-    };
-  }
-}
-
-// src/tools/finance.ts
-var financeTool = {
-  name: "finance_analyze",
-  description: "\u5206\u6790\u4E0A\u5E02\u516C\u53F8\u8D22\u52A1\u6570\u636E\u5E76\u751F\u6210\u7814\u7A76\u62A5\u544A",
-  parameters: {
-    type: "object",
-    properties: {
-      company: {
-        type: "string",
-        description: "\u516C\u53F8\u540D\u79F0"
-      },
-      code: {
-        type: "string",
-        description: "\u80A1\u7968\u4EE3\u7801"
-      },
-      market: {
-        type: "string",
-        enum: ["A", "HK"],
-        description: "\u5E02\u573A\u7C7B\u578B (A: A\u80A1, HK: \u6E2F\u80A1)"
-      }
-    },
-    required: ["company", "code"]
-  },
-  execute: async (params) => {
-    try {
-      const dataSource = new AkshareDataSource();
-      const engine = new WorkflowEngine({
-        nodes: [
-          (state) => dataCollectionNode(state, dataSource),
-          analysisNode,
-          reportNode
-        ]
-      });
-      const result = await engine.execute({
-        company: params.company,
-        code: params.code,
-        market: params.market || "A"
-      });
-      return {
-        output: result.output.report || "\u5206\u6790\u5B8C\u6210"
-      };
-    } catch (error) {
-      return {
-        output: "",
-        error: error.message
-      };
-    }
-  }
-};
-
-// src/tools/index.ts
-var builtinTools = [
-  readFileTool,
-  writeFileTool,
-  editFileTool,
-  bashTool,
-  globTool,
-  grepTool,
-  financeTool
-];
-
-// src/core/orchestrator.ts
-var Orchestrator = class {
-  messages = [];
-  tools;
-  model;
-  systemPrompt;
-  maxIterations;
-  callbacks;
-  constructor(opts) {
-    this.model = opts.model;
-    this.systemPrompt = opts.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
-    if (opts.skillInstructions) {
-      this.systemPrompt += "\n\n" + opts.skillInstructions;
-    }
-    this.tools = opts.tools ?? builtinTools;
-    this.maxIterations = opts.maxIterations ?? 20;
-    this.callbacks = {
-      onToken: opts.onToken,
-      onToolStart: opts.onToolStart,
-      onToolEnd: opts.onToolEnd
-    };
-    if (this.systemPrompt) {
-      this.messages.push({ role: "system", content: this.systemPrompt });
-    }
-  }
-  async run(userMessage) {
-    this.messages.push({ role: "user", content: userMessage });
-    for (let i = 0; i < this.maxIterations; i++) {
-      const response = await this.model.chat(this.messages, this.tools);
-      if (response.content) {
-        this.messages.push({
-          role: "assistant",
-          content: response.content,
-          tool_calls: response.tool_calls
-        });
-      }
-      if (!response.tool_calls?.length) {
-        return response.content;
-      }
-      for (const tc of response.tool_calls) {
-        this.callbacks.onToolStart?.(
-          tc.function.name,
-          JSON.parse(tc.function.arguments)
-        );
-        const result = await this.executeTool(tc);
-        this.callbacks.onToolEnd?.(tc.function.name, result);
-        this.messages.push({
-          role: "tool",
-          content: result.error ? `Error: ${result.error}` : result.output,
-          tool_call_id: tc.id
-        });
-      }
-    }
-    return "Max iterations reached.";
-  }
-  async *runStream(userMessage) {
-    this.messages.push({ role: "user", content: userMessage });
-    for (let i = 0; i < this.maxIterations; i++) {
-      let fullContent = "";
-      let toolCalls = [];
-      for await (const chunk of this.model.stream(this.messages, this.tools)) {
-        if (chunk.content) {
-          fullContent += chunk.content;
-          yield chunk.content;
-        }
-        if (chunk.tool_calls) {
-          toolCalls = chunk.tool_calls;
-        }
-      }
-      if (!toolCalls.length) {
-        this.messages.push({ role: "assistant", content: fullContent });
-        return;
-      }
-      this.messages.push({
-        role: "assistant",
-        content: fullContent,
-        tool_calls: toolCalls
-      });
-      for (const tc of toolCalls) {
-        this.callbacks.onToolStart?.(
-          tc.function.name,
-          JSON.parse(tc.function.arguments)
-        );
-        const result = await this.executeTool(tc);
-        this.callbacks.onToolEnd?.(tc.function.name, result);
-        this.messages.push({
-          role: "tool",
-          content: result.error ? `Error: ${result.error}` : result.output,
-          tool_call_id: tc.id
-        });
-      }
-    }
-  }
-  async executeTool(tc) {
-    const tool = this.tools.find((t) => t.name === tc.function.name);
-    if (!tool) return { output: "", error: `Unknown tool: ${tc.function.name}` };
-    try {
-      const params = JSON.parse(tc.function.arguments);
-      return await tool.execute(params);
-    } catch (e) {
-      return { output: "", error: e.message };
-    }
-  }
-  getMessages() {
-    return [...this.messages];
-  }
-  clearMessages() {
-    this.messages = [];
-    if (this.systemPrompt) {
-      this.messages.push({ role: "system", content: this.systemPrompt });
-    }
-  }
-};
-var DEFAULT_SYSTEM_PROMPT = `You are Hecode, an AI coding assistant. You help users with software engineering tasks using the tools available to you.
-
-Key principles:
-- Be concise and direct
-- Use tools to read/write files, execute commands, and search code
-- Verify your work by running tests or checks when possible
-- Follow existing code conventions in the project`;
-
-export {
-  Orchestrator
-};
-//# sourceMappingURL=chunk-I4W33CWB.js.map