qlogicagent 0.5.2 → 0.6.0

package/dist/types/skills/tools/web-search-tool.d.ts

@@ -0,0 +1,57 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const WEB_SEARCH_TOOL_NAME: "web_search";
+export interface WebSearchToolParams {
+    query: string;
+    allowedDomains?: string[];
+    blockedDomains?: string[];
+}
+export declare const WEB_SEARCH_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly query: {
+            readonly type: "string";
+            readonly description: "Search query string. Be specific and concise for best results.";
+        };
+        readonly allowedDomains: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: string;
+        };
+        readonly blockedDomains: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "Exclude results from these domains. Cannot be used together with allowedDomains.";
+        };
+    };
+    readonly required: readonly ["query"];
+};
+export interface WebSearchResult {
+    title: string;
+    url: string;
+    snippet: string;
+}
+export interface WebSearchOutput {
+    query: string;
+    results: WebSearchResult[];
+    totalResults?: number;
+}
+/**
+ * Host-provided web search backend.
+ * The host may use any search engine (SearXNG, Brave, Tavily, etc.).
+ */
+export interface WebSearchToolDeps {
+    /**
+     * Execute a web search and return results.
+     * The host is responsible for API key management and rate limiting.
+     */
+    search(query: string, options?: {
+        allowedDomains?: string[];
+        blockedDomains?: string[];
+        maxResults?: number;
+    }): Promise<WebSearchOutput>;
+}
+export declare function createWebSearchTool(deps: WebSearchToolDeps): PortableTool<WebSearchToolParams>;

package/dist/types/skills/tools/workflow-tool.d.ts

@@ -0,0 +1,44 @@
+import type { PortableTool } from "../portable-tool.js";
+export type WorkflowAction = "list" | "run" | "describe";
+export interface WorkflowStep {
+    /** Step identifier */
+    id: string;
+    /** Tool name to invoke */
+    tool: string;
+    /** Tool arguments (supports ${prev.result} interpolation) */
+    args: Record<string, unknown>;
+    /** Step IDs this step depends on (for DAG ordering) */
+    dependsOn?: string[];
+    /** Condition expression: "always" | "on_success" | "on_failure" (default: "on_success") */
+    condition?: "always" | "on_success" | "on_failure";
+    /** Human-readable label */
+    label?: string;
+}
+export interface WorkflowDefinition {
+    /** Workflow name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Ordered steps (executed in dependency order) */
+    steps: WorkflowStep[];
+    /** Variables that can be overridden at runtime */
+    variables?: Record<string, string>;
+}
+export interface WorkflowToolParams {
+    /** Action to perform */
+    action: WorkflowAction;
+    /** Workflow name (for run/describe) */
+    workflow?: string;
+    /** Variable overrides (for run) */
+    variables?: Record<string, string>;
+}
+export interface WorkflowToolDeps {
+    /** Execute a tool by name and return its text result */
+    invokeTool(toolName: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<{
+        result: string;
+        error?: string;
+    }>;
+    /** Get current working directory */
+    getCwd(): string;
+}
+export declare function createWorkflowTool(deps: WorkflowToolDeps): PortableTool<WorkflowToolParams>;

package/dist/types/skills/tools/worktree-tool.d.ts

@@ -0,0 +1,69 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const WORKTREE_TOOL_NAME: "worktree";
+export type WorktreeAction = "enter" | "exit" | "list";
+export interface WorktreeToolParams {
+    /** Action: enter (create worktree), exit (leave worktree), list (show all) */
+    action: WorktreeAction;
+    /** Branch/worktree name (for enter). kebab-case, max 64 chars. */
+    name?: string;
+    /** For exit: 'keep' retains the worktree, 'remove' deletes it */
+    exitAction?: "keep" | "remove";
+    /** Required true to discard uncommitted changes on exit with remove */
+    discardChanges?: boolean;
+}
+export declare const WORKTREE_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly action: {
+            readonly type: "string";
+            readonly enum: readonly ["enter", "exit", "list"];
+            readonly description: string;
+        };
+        readonly name: {
+            readonly type: "string";
+            readonly description: string;
+        };
+        readonly exitAction: {
+            readonly type: "string";
+            readonly enum: readonly ["keep", "remove"];
+            readonly description: "For exit: 'keep' retains the worktree for later use; 'remove' deletes it.";
+        };
+        readonly discardChanges: {
+            readonly type: "boolean";
+            readonly description: string;
+        };
+    };
+    readonly required: readonly ["action"];
+};
+export interface WorktreeInfo {
+    name: string;
+    path: string;
+    branch: string;
+    isCurrent: boolean;
+    hasChanges: boolean;
+    unpushedCommits: number;
+}
+export interface WorktreeResult {
+    success: boolean;
+    worktree?: WorktreeInfo;
+    worktrees?: WorktreeInfo[];
+    previousCwd?: string;
+    error?: string;
+}
+/**
+ * Host-provided git worktree backend.
+ * Manages worktree creation, switching, and cleanup.
+ */
+export interface WorktreeToolDeps {
+    /** Create a new worktree and switch session cwd */
+    enterWorktree(name?: string): Promise<WorktreeResult>;
+    /** Exit worktree (keep or remove) */
+    exitWorktree(action: "keep" | "remove", discardChanges?: boolean): Promise<WorktreeResult>;
+    /** List all worktrees */
+    listWorktrees(): Promise<WorktreeResult>;
+    /** Check if currently in a worktree */
+    isInWorktree(): boolean;
+    /** Get current worktree info */
+    currentWorktree?(): WorktreeInfo | null;
+}
+export declare function createWorktreeTool(deps: WorktreeToolDeps): PortableTool<WorktreeToolParams>;

package/dist/types/skills/tools/write-tool.d.ts

@@ -0,0 +1,45 @@
+import type { PortableTool } from "../portable-tool.js";
+export declare const WRITE_TOOL_NAME: "write";
+export interface WriteToolParams {
+    path: string;
+    content: string;
+}
+export declare const WRITE_TOOL_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly path: {
+            readonly type: "string";
+            readonly description: "Absolute path to the file to write.";
+        };
+        readonly content: {
+            readonly type: "string";
+            readonly description: "Content to write to the file.";
+        };
+    };
+    readonly required: readonly ["path", "content"];
+};
+/** Deps injected by the host runtime for file writing. */
+export interface WriteToolDeps {
+    /** Write content to a file. Create parent dirs as needed. */
+    writeFile(path: string, content: string): Promise<void>;
+    /** Resolve a relative path to absolute. */
+    resolvePath(input: string): string;
+    /**
+     * Check if file has been read before writing (first-read-then-write protection).
+     * Returns null if write is allowed, or a warning message.
+     * If not provided, no protection is applied.
+     */
+    checkReadBeforeWrite?(path: string): string | null;
+    /**
+     * Validate write access for the given path.
+     * Returns null if allowed, or an error message if blocked.
+     */
+    validatePath?(path: string): string | null;
+    /**
+     * Check for concurrent modification before overwriting an existing file.
+     * Returns null if safe to write, or a warning if modified since last read.
+     * If not provided, no concurrent modification check is performed.
+     */
+    checkConcurrentModification?(path: string): string | null;
+}
+export declare function createWriteTool(deps: WriteToolDeps): PortableTool<WriteToolParams>;

package/dist/types/skills/tools.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Tool Registry — CC-aligned getAllBaseTools() pattern.
+ *
+ * CC reference: claude-code-haha/src/tools.ts
+ *
+ * This is the SINGLE SOURCE OF TRUTH for all available tools.
+ * Tools are returned as a flat array from getAllBaseTools().
+ * Filtering/gating happens via getTools() using deny rules.
+ *
+ * Factory functions (createXxxTool) are kept because qlogicagent
+ * tools receive deps at creation time (vs CC context at call time).
+ * The registration pattern is aligned: pure function returns array.
+ */
+import type { PortableTool } from "./portable-tool.js";
+import type { ToolDefinition } from "../agent/types.js";
+import { AGENT_DISALLOWED_TOOLS, CUSTOM_AGENT_DISALLOWED_TOOLS, filterToolsForAgent } from "../agent/tool-access.js";
+export { AGENT_DISALLOWED_TOOLS, CUSTOM_AGENT_DISALLOWED_TOOLS, filterToolsForAgent };
+/**
+ * Register tools into the internal pool. Called by initToolDeps().
+ */
+export declare function setToolPool(tools: PortableTool[]): void;
+/**
+ * Add a single tool to the pool (for dynamic tools like MCP, plugins).
+ */
+export declare function addTool(tool: PortableTool<any>): void;
+/**
+ * Add multiple tools to the pool at once.
+ */
+export declare function addTools(tools: PortableTool<any>[]): void;
+/**
+ * Remove a tool by name. Returns true if it existed.
+ */
+export declare function removeTool(name: string): boolean;
+/**
+ * Find a tool by name.
+ */
+export declare function findTool(name: string): PortableTool | undefined;
+/**
+ * Check if a tool exists.
+ */
+export declare function hasTool(name: string): boolean;
+/**
+ * Get all tool names.
+ */
+export declare function getToolNames(): string[];
+/**
+ * Get the number of registered tools.
+ */
+export declare function getToolCount(): number;
+/**
+ * Execute a tool by name.
+ */
+export declare function executeTool(name: string, toolCallId: string, args: Record<string, unknown>, signal?: AbortSignal): Promise<import("./portable-tool.js").PortableToolResult>;
+/**
+ * CC: getTools() — return all enabled tools.
+ * Filters the pool by isEnabled() gate; disabled tools are invisible to callers.
+ * CC reference: claude-code-haha/src/tools.ts getTools()
+ */
+export declare function getTools(): PortableTool[];
+/**
+ * Generate ToolDefinition[] manifest for LLM tool_use.
+ * Filters by isEnabled() — disabled tools never reach the model.
+ * CC: getTools() + manifest generation combined.
+ */
+export declare function getToolManifest(includeDeferred?: boolean): ToolDefinition[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qlogicagent",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "XiaozhiClaw Agent CLI — subprocess architecture (JSON-RPC over stdio)",
   "type": "module",
   "main": "dist/index.js",
@@ -32,10 +32,11 @@
     "dev": "tsx watch src/index.ts",
     "build": "node scripts/build.mjs",
     "build:tsc": "tsc --noCheck",
-    "start": "node dist/cli/main.js",
+    "start": "node dist/cli.js",
     "test": "vitest run",
     "test:watch": "vitest",
-    "lint": "oxlint ."
+    "lint": "oxlint .",
+    "release": "node scripts/release.mjs"
   },
   "engines": {
     "node": ">=22.0.0"