@24klynx/tools 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,519 @@
+//#region src/types.d.ts
+/**
+ * Core types for the tool system.
+ *
+ * Every tool is described by a {@link ToolDescriptor} and handled by
+ * a {@link ToolHandler}. The registry maps descriptors to handlers via
+ * an executor ref key.
+ */
+/** The kind of side‑effects a tool has. */
+type ToolKind = "ReadOnly" | "WritesFiles" | "ExecutesCode" | "Network";
+/** 4‑level safety classification (mirrors Claude Code / CodeWhale). */
+type CommandSafety = "Safe" | "WorkspaceSafe" | "RequiresApproval" | "Dangerous";
+/** Identifies which plugin (or "core") owns this tool. */
+type ToolOwnerRef = string;
+/** Routing key — resolved by the registry to find the handler. */
+type ToolExecutorRef = string;
+/**
+ * Static description of a tool — its name, schema, safety level, and
+ * when it should be visible.
+ *
+ * Registered once at startup and stays immutable for the session lifetime.
+ */
+interface ToolDescriptor {
+  /** Unique tool name, e.g. "bash" or "read_file". */
+  name: string;
+  /** Human‑readable description injected into the LLM system prompt. */
+  description: string;
+  /** JSON Schema for the tool's input parameters. */
+  inputSchema: Record<string, unknown>;
+  /** Side‑effect category. */
+  kind: ToolKind;
+  /** Baseline safety level. */
+  safety: CommandSafety;
+  /** When this tool is visible — evaluated each turn. */
+  availability: AvailabilityExpr;
+  /** Key to look up the handler in the registry. */
+  executor: ToolExecutorRef;
+  /** "core" or the plugin id that registered this tool. */
+  owner: ToolOwnerRef;
+}
+/**
+ * Expression tree for tool availability.
+ *
+ * Evaluated at the start of every turn to determine which tools
+ * are visible in the LLM tool catalog.
+ */
+type AvailabilityExpr = {
+  type: "always";
+} | {
+  type: "never";
+  reason: string;
+} | {
+  type: "env";
+  key: string;
+  equals: string;
+} | {
+  type: "setting";
+  path: string;
+  equals: unknown;
+} | {
+  type: "flag";
+  flag: string;
+} | {
+  type: "platform";
+  platform: "windows" | "linux";
+} | {
+  type: "mcp_connected";
+  serverName: string;
+} | {
+  type: "has_plugin";
+  pluginId: string;
+} | {
+  type: "session_mode";
+  mode: string;
+} | {
+  type: "all";
+  exprs: AvailabilityExpr[];
+} | {
+  type: "any";
+  exprs: AvailabilityExpr[];
+} | {
+  type: "not";
+  expr: AvailabilityExpr;
+};
+/** Result of the tool planner — which tools go to the LLM. */
+interface ToolPlan {
+  /** Tools that will appear in the LLM catalog. */
+  visible: ToolDescriptor[];
+  /** Tools that are hidden (unavailable), each with a reason. */
+  hidden: HiddenTool[];
+}
+/** A tool that was hidden with the reason why. */
+interface HiddenTool {
+  tool: ToolDescriptor;
+  reason: string;
+}
+/** A single tool invocation created by the LLM. */
+interface ToolInvocation {
+  /** Unique call id from the provider's tool_use block. */
+  callId: string;
+  /** Tool name as registered. */
+  toolName: string;
+  /** Parsed tool input (provider‑side consolidation). */
+  payload: Record<string, unknown>;
+}
+/** The handler that actually executes a tool. */
+interface ToolHandler {
+  /**
+   * Execute the tool.
+   *
+   * Each handler receives an AbortSignal — when the user hits Ctrl+C,
+   * the signal fires and the handler should stop as soon as possible.
+   */
+  handle(invocation: ToolInvocation, signal: AbortSignal): Promise<ToolResult>;
+}
+/** Result of a completed tool execution. */
+interface ToolResult {
+  /** Whether execution succeeded (false = error). */
+  success: boolean;
+  /** Human‑readable output text. */
+  content: string;
+  /** Optional metadata for the rendering layer. */
+  metadata?: {
+    /** Wall‑clock duration in milliseconds. */durationMs: number; /** Whether the output was truncated. */
+    truncated?: boolean; /** Where the truncation occurred (character index). */
+    truncatedAt?: number;
+  };
+}
+//#endregion
+//#region src/availability.d.ts
+/**
+ * Snapshot of the runtime environment passed to the availability evaluator.
+ * Updated each turn before `buildToolPlan()` runs.
+ */
+interface EvalContext {
+  /** Current platform ("windows" | "linux"). */
+  platform: "windows" | "linux";
+  /** Current permission mode (from the session). */
+  sessionMode: string;
+  /** Enabled feature flags. */
+  flags: Set<string>;
+  /** Settings/configuration values keyed by dot‑path. */
+  settings: Record<string, unknown>;
+  /** Environment variable overrides. */
+  env: Record<string, string>;
+  /** Connected MCP server names. */
+  connectedMcpServers: Set<string>;
+  /** Loaded plugin ids. */
+  loadedPlugins: Set<string>;
+}
+/**
+ * Evaluate an availability expression against the current context.
+ *
+ * Returns `{ available: true }` or `{ available: false, reason: string }`.
+ *
+ * ```ts
+ * const result = evaluateAvailability(expr, ctx);
+ * if (!result.available) {
+ *   console.log(`Tool hidden because: ${result.reason}`);
+ * }
+ * ```
+ */
+declare function evaluateAvailability(expr: AvailabilityExpr, ctx: EvalContext): {
+  available: boolean;
+  reason?: string;
+};
+//#endregion
+//#region src/registry.d.ts
+/**
+ * In‑memory registry of all registered tools and their handlers.
+ *
+ * Create one instance per process in the bootstrap phase.
+ */
+interface ToolRegistry {
+  /** Register a tool descriptor and its handler. */
+  register(descriptor: ToolDescriptor, handler: ToolHandler): void;
+  /** Look up a descriptor by name. Returns undefined if not found. */
+  resolve(name: string): ToolDescriptor | undefined;
+  /** Look up a handler by executor key. Throws if not registered. */
+  resolveExecutor(descriptor: ToolDescriptor): ToolHandler;
+  /** Return every registered descriptor. */
+  listAll(): ToolDescriptor[];
+  /** Return the total number of registered tools. */
+  count(): number;
+}
+/**
+ * Create a new empty ToolRegistry.
+ */
+declare function createToolRegistry(): ToolRegistry;
+//#endregion
+//#region src/builtin/files/read-file.d.ts
+declare const descriptor$3: ToolDescriptor;
+declare const handler: ToolHandler;
+//#endregion
+//#region src/builtin/agent/task.d.ts
+/**
+ * TaskManager 的最小接口 — lynx-tools 不依赖 lynx-agent，
+ * 实际实例在 bootstrap 时注入。
+ */
+interface TaskManagerOps {
+  start(id: string, label: string, run: (signal: AbortSignal) => Promise<void>): Promise<void>;
+  stop(id: string): Promise<void>;
+  get(id: string): {
+    id: string;
+    label: string;
+    status: string;
+    startedAt: number;
+    stoppedAt?: number;
+    error?: string;
+    output?: string;
+    progress?: number;
+  } | undefined;
+  list(): Array<{
+    id: string;
+    label: string;
+    status: string;
+  }>;
+  getOutput(id: string): string;
+  update(id: string, patch: {
+    label?: string;
+    status?: string;
+  }): void;
+}
+/**
+ * Inject the real TaskManager backend.
+ *
+ * Called during bootstrap after the engine is created.
+ * Before injection, the handler returns mock results for test compatibility.
+ */
+declare function injectTaskManager(tm: TaskManagerOps): void;
+/**
+ * Create a task handler bound to a specific {@link TaskManagerOps}.
+ *
+ * Factory alternative to {@link injectTaskManager} — useful when the
+ * handler needs to be registered independently of the module‑level singleton.
+ */
+declare function createTaskHandler(tm: TaskManagerOps): ToolHandler;
+//#endregion
+//#region ../lynx-agent/src/memory/manager.d.ts
+/**
+ * Memory manager — persistent key‑value facts that survive
+ * across sessions.
+ *
+ * Memory entries are simple markdown files with frontmatter,
+ * stored in a configured directory. The agent can read/write
+ * memories via tools.
+ *
+ * Pattern: inspired by Claude Code's memory system —
+ *   ● Each fact is one file
+ *   ● Frontmatter contains metadata (type, tags, timestamp)
+ *   ● An index file (MEMORY.md) lists all entries for fast scanning
+ *   ● Loading reads the index first, then lazy‑loads individual files
+ */
+interface MemoryEntry {
+  /** File stem (slug). */
+  name: string;
+  /** Short description for relevance matching. */
+  description: string;
+  /** When the entry was last modified (Unix ms). */
+  updatedAt: number;
+  /** Full markdown content (lazy‑loaded). */
+  content?: string;
+  /** Metadata from frontmatter. */
+  type: "user" | "feedback" | "project" | "reference";
+  /** Absolute file path on disk. */
+  filePath: string;
+  /** Arbitrary extra metadata fields from frontmatter (e.g. tags, source). */
+  metadata?: Record<string, unknown>;
+}
+interface MemoryManager {
+  /** Load the index (all memory names + descriptions). */
+  list(): MemoryEntry[];
+  /** Load a single memory entry by name. */
+  get(name: string): MemoryEntry | undefined;
+  /** Write (create or update) a memory entry. */
+  put(entry: MemoryEntry): void;
+  /** Delete a memory entry by name. */
+  delete(name: string): boolean;
+  /** Reload the index from disk. */
+  reload(): void;
+  /** 全文搜索记忆 — 在名称、描述、内容中匹配关键词。按相关度排序。 */
+  search(query: string): MemoryEntry[];
+  /** 去重压缩 — 合并 Jaccard 相似度 > 0.8 的条目。返回合并后的条目列表。 */
+  compact(): MemoryEntry[];
+  /** 按 glob 模式批量删除匹配的记忆。返回删除的条目数。 */
+  forget(pattern: string): number;
+  /** 将所有记忆序列化为 JSON 字符串。 */
+  exportAll(): string;
+  /** 从 JSON 字符串批量导入记忆。跳过已存在的同名条目。返回导入数量。 */
+  importAll(data: string): number;
+  /** 合并另一个 memory 目录中的记忆文件。跳过冲突。返回合并的条目数。 */
+  merge(sourceDir: string): number;
+}
+//#endregion
+//#region src/builtin/memory/memory-write.d.ts
+declare const descriptor$1: ToolDescriptor;
+/**
+ * 创建绑定到指定 {@link MemoryManager} 的 memory_write 处理器。
+ *
+ * 工厂模式 — 管理器在启动时注入，使工具写入真实的 memory 目录。
+ */
+declare function createMemoryWriteHandler(memoryManager: MemoryManager): ToolHandler;
+//#endregion
+//#region src/builtin/mcp/mcp-auth.d.ts
+/** McpManager 的最小接口 — lynx-tools 不依赖 lynx-agent。 */
+interface McpAuthOps {
+  reconnect(serverName: string): Promise<{
+    status: string;
+  }>;
+}
+/** 工具描述符 — 注册到 ToolRegistry 的静态元数据。 */
+declare const descriptor: ToolDescriptor;
+/**
+ * 创建 McpAuthTool 的 handler，绑定到给定的 McpAuthOps。
+ *
+ * 工厂模式 — 实际 McpManager 在 bootstrap 时注入。
+ */
+declare function createMcpAuthHandler(mcpOps: McpAuthOps): ToolHandler;
+//#endregion
+//#region src/builtin/interact/send-message.d.ts
+/** 消息发送器接口 —— 由调用方注入具体实现。 */
+interface MessageSender {
+  /**
+   * 通过指定通道发送消息。
+   * @param channel 通道标识（如 "feishu"）
+   * @param content 消息内容
+   * @param recipients 可选接收人列表
+   * @returns 包含 messageId 的结果
+   */
+  send(channel: string, content: string, recipients?: string[]): Promise<{
+    messageId: string;
+  }>;
+}
+declare const descriptor$2: ToolDescriptor;
+/**
+ * 创建 SendMessageTool 的处理器。
+ *
+ * 通过工厂注入 MessageSender 实现，避免直接 import lynx-channels。
+ * 在 bootstrap 阶段将真实的通道发送器注入此处。
+ */
+declare function createSendMessageHandler(sender: MessageSender): ToolHandler;
+//#endregion
+//#region src/builtin/index.d.ts
+/** All built‑in (descriptor, handler) pairs in registration order. */
+declare const BUILTIN_TOOLS: Array<{
+  descriptor: typeof descriptor$3;
+  handler: typeof handler;
+}>;
+/**
+ * Register all built‑in tool (descriptor, handler) pairs with the given registry.
+ *
+ * Each pair is registered atomically — if one fails (duplicate name), the error
+ * propagates so the caller can decide whether to abort or skip.
+ */
+declare function registerBuiltinTools(registry: ToolRegistry): void;
+/** Return the list of built‑in descriptors (without registering). */
+declare function listBuiltinDescriptors(): (typeof BUILTIN_TOOLS)[number]["descriptor"][];
+//#endregion
+//#region src/planner.d.ts
+/**
+ * Compute the tool plan for the current turn.
+ *
+ * Every registered tool is evaluated against the availability context.
+ * Visible tools go into the LLM catalog; hidden tools are returned with
+ * a reason so the debug/log layer can report them.
+ *
+ * ```ts
+ * const plan = buildToolPlan(registry, evalCtx);
+ * console.log(`${plan.visible.length} visible, ${plan.hidden.length} hidden`);
+ * ```
+ */
+declare function buildToolPlan(registry: ToolRegistry, ctx: EvalContext): ToolPlan;
+//#endregion
+//#region src/safety.d.ts
+/**
+ * Escalate the safety level if the command touches a sensitive path.
+ *
+ * Uses the 4‑level sensitivity classification from {@link classifySensitivity}.
+ * Even a "Safe" tool becomes Dangerous if it tries to read ~/.ssh.
+ */
+declare function escalateForSensitivePaths(safety: CommandSafety, paths: string[]): CommandSafety;
+/**
+ * Returns true if the tool requires interactive user confirmation.
+ */
+declare function needsApproval(safety: CommandSafety): boolean;
+/**
+ * Returns true if the tool can run automatically in yolo/headless mode.
+ */
+declare function isHeadlessSafe(safety: CommandSafety): boolean;
+/** Human‑readable labels for each safety level. */
+declare const SAFETY_LABELS: Record<CommandSafety, string>;
+//#endregion
+//#region src/safety/sanitize.d.ts
+/**
+ * Unicode sanitization — remove invisible and control characters
+ * that could be used for prompt injection attacks.
+ *
+ * All patterns use new RegExp() with \\uXXXX string escapes
+ * to avoid filesystem encoding of literal Unicode characters.
+ *
+ * References:
+ *   - Unicode Technical Report #36 (Security Considerations)
+ *   - CWE-838: Inappropriate Encoding for Output Context
+ */
+/**
+ * Strip invisible and potentially dangerous Unicode characters from text.
+ *
+ * Preserves CJK Unified ideographs, emoji, combining diacritical marks,
+ * and other legitimate Unicode.
+ */
+declare function sanitizeUnicode(input: string): string;
+//#endregion
+//#region src/safety/path-check.d.ts
+/**
+ * Path traversal / jailbreak detection.
+ *
+ * Verifies that a resolved file path stays within the workspace root.
+ * Also catches null-byte injection attacks that can truncate paths
+ * in C‑based filesystem APIs.
+ */
+/**
+ * Check whether a file path is safely contained within the workspace root.
+ *
+ * Algorithm:
+ *   1. Reject paths containing null bytes (truncation attack).
+ *   2. Resolve to absolute path, eliminating `../` segments.
+ *   3. Resolve symlinks to their real physical location.
+ *   4. Verify the final path starts with the workspace root.
+ *
+ * @returns true if the path is safely inside the workspace.
+ */
+declare function isPathSafe(filePath: string, workspaceRoot: string): boolean;
+//#endregion
+//#region src/safety/trusted-cmd.d.ts
+/**
+ * Trusted command whitelist — commands that are safe to execute
+ * without interactive user confirmation.
+ *
+ * These are read‑only or read‑heavy commands that don't modify
+ * the filesystem or network. Even in `--yolo` mode, commands
+ * not on this list still go through safety escalation.
+ */
+/**
+ * Check if a command is on the trusted whitelist.
+ *
+ * For commands with sub‑command gating (git, npm, pnpm),
+ * the first argument is checked against allowed sub‑commands.
+ */
+declare function isTrustedCommand(command: string, args?: string[]): boolean;
+//#endregion
+//#region src/safety/blocked-cmd.d.ts
+/**
+ * Blocked command blacklist — commands that are ALWAYS rejected
+ * regardless of permission mode (including `--yolo`).
+ *
+ * These patterns match destructive or privilege‑escalation operations
+ * that should never run through an AI agent.
+ */
+/**
+ * Check if a command string matches any blocked pattern.
+ *
+ * @returns The block reason if blocked, or null if safe.
+ */
+declare function isBlockedCommand(command: string, args?: string[]): {
+  blocked: true;
+  reason: string;
+} | {
+  blocked: false;
+};
+//#endregion
+//#region src/safety/redact.d.ts
+/**
+ * Secret / key redaction — detect and redact sensitive credentials
+ * from output before displaying to the user or logging.
+ *
+ * This is a defense‑in‑depth layer. The primary defense is never
+ * reading .env / secret files, but if a secret leaks into output
+ * (e.g. from a tool result or LLM response), we redact it here.
+ */
+/**
+ * Redact all detected secrets from the given text.
+ *
+ * @returns The text with secrets replaced by `[REDACTED]` or `sk-...XyZ1`.
+ */
+declare function redactSecrets(text: string): string;
+//#endregion
+//#region src/safety/sensitive.d.ts
+/**
+ * Sensitive file classification — 4‑level protection system.
+ *
+ * Levels (increasing severity):
+ *   Low       — normal files, write allowed
+ *   Medium    — config/build files, write prompts confirmation
+ *   High      — env/secret files, read‑only (write blocked)
+ *   Critical  — SSH/GPG keys, never read or write
+ *
+ * This replaces the flat `SENSITIVE_PATHS` Set in safety.ts
+ * with a tiered system that enables fine‑grained access control.
+ */
+type SensitivityLevel = "Low" | "Medium" | "High" | "Critical";
+/**
+ * Classify a file path by sensitivity level.
+ *
+ * The path is tested against all rules in order. The first match wins.
+ * Negation patterns (`!`) remove previous matches at the same level.
+ *
+ * @returns The sensitivity level for the given path.
+ */
+declare function classifySensitivity(filePath: string): SensitivityLevel;
+//#endregion
+//#region src/safety/index.d.ts
+/** A single blocked command pattern (for external display / config). */
+interface BlockedPattern {
+  reason: string;
+  pattern: string;
+}
+//#endregion
+export { type AvailabilityExpr, type BlockedPattern, type CommandSafety, type EvalContext, type HiddenTool, SAFETY_LABELS, type SensitivityLevel, type ToolDescriptor, type ToolExecutorRef, type ToolHandler, type ToolInvocation, type ToolKind, type ToolOwnerRef, type ToolPlan, type ToolRegistry, type ToolResult, buildToolPlan, classifySensitivity as classifyPath, createMcpAuthHandler, createMemoryWriteHandler, createSendMessageHandler, createTaskHandler, createToolRegistry, escalateForSensitivePaths, evaluateAvailability, injectTaskManager, isBlockedCommand, isHeadlessSafe, isTrustedCommand, isPathSafe as isWithinWorkspace, listBuiltinDescriptors, descriptor as mcpAuthDescriptor, descriptor$1 as memoryWriteDescriptor, needsApproval, redactSecrets, registerBuiltinTools, sanitizeUnicode, descriptor$2 as sendMessageDescriptor };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/availability.ts","../src/registry.ts","../src/builtin/files/read-file.ts","../src/builtin/agent/task.ts","../../lynx-agent/src/memory/manager.ts","../src/builtin/memory/memory-write.ts","../src/builtin/mcp/mcp-auth.ts","../src/builtin/interact/send-message.ts","../src/builtin/index.ts","../src/planner.ts","../src/safety.ts","../src/safety/sanitize.ts","../src/safety/path-check.ts","../src/safety/trusted-cmd.ts","../src/safety/blocked-cmd.ts","../src/safety/redact.ts","../src/safety/sensitive.ts","../src/safety/index.ts"],"mappings":"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"}