@nuvin/agent-core 0.0.0-rc.9 → 0.1.0-rc.0

package/dist/tools/ask-user-tool.d.ts

@@ -0,0 +1,55 @@
+export declare function createAskUserTool(): import("../shared/types.ts").ToolDefinition<{
+    answers: {};
+    questions: {
+        question: string;
+        topic: string;
+        options: {
+            label: string;
+            description: string;
+        }[];
+        multiSelect: boolean;
+    }[];
+}, import("../shared/types.ts").ToolOutputEnvelope, import("../shared/types.ts").ToolOutputEnvelope | undefined, {
+    type: "object";
+    properties: {
+        questions: {
+            type: "array";
+            items: {
+                type: "object";
+                properties: {
+                    question: {
+                        type: "string";
+                    };
+                    topic: {
+                        type: "string";
+                    };
+                    options: {
+                        type: "array";
+                        items: {
+                            type: "object";
+                            properties: {
+                                label: {
+                                    type: "string";
+                                };
+                                description: {
+                                    type: "string";
+                                };
+                            };
+                            required: string[];
+                        };
+                    };
+                    multiSelect: {
+                        type: "boolean";
+                    };
+                };
+                required: string[];
+            };
+        };
+        answers: {
+            type: "object";
+            properties: {};
+        };
+    };
+    required: string[];
+}>;
+//# sourceMappingURL=ask-user-tool.d.ts.map

package/dist/tools/background-process-registry.d.ts

@@ -0,0 +1,64 @@
+import type { ChildProcess } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+export type BackgroundProcessStatus = "running" | "exited" | "killed" | "error";
+export interface BackgroundProcessEntry {
+    shellId: string;
+    command: string;
+    cwd: string;
+    pid: number | undefined;
+    status: BackgroundProcessStatus;
+    exitCode: number | null;
+    signal: NodeJS.Signals | null;
+    startedAt: number;
+    error?: string;
+    child: ChildProcess | null;
+    buffer: string[];
+    bufferChars: number;
+    totalProduced: number;
+    totalDropped: number;
+    readCursor: number;
+    stdoutDecoder: StringDecoder;
+    stderrDecoder: StringDecoder;
+    stripAnsi: boolean;
+    killRequested: boolean;
+    processExited: boolean;
+}
+export interface BackgroundProcessReadResult {
+    output: string;
+    status: BackgroundProcessStatus;
+    exitCode: number | null;
+    signal: NodeJS.Signals | null;
+    truncated: boolean;
+}
+export interface BackgroundProcessRegistryOptions {
+    maxConcurrent?: number;
+    maxEntries?: number;
+    capChars?: number;
+}
+export declare class BackgroundProcessRegistry {
+    private readonly entries;
+    private readonly maxConcurrent;
+    private readonly maxEntries;
+    private readonly capChars;
+    private counter;
+    constructor(opts?: BackgroundProcessRegistryOptions);
+    spawn(opts: {
+        child: ChildProcess;
+        command: string;
+        cwd: string;
+        stripAnsi: boolean;
+    }): BackgroundProcessEntry;
+    read(shellId: string, opts?: {
+        regex?: string;
+    }): BackgroundProcessReadResult;
+    list(): BackgroundProcessEntry[];
+    kill(shellId: string): {
+        status: BackgroundProcessStatus;
+        exitCode: number | null;
+        signal: NodeJS.Signals | null;
+    };
+    closeAll(): Promise<void>;
+    private append;
+    private evictIfNeeded;
+}
+//# sourceMappingURL=background-process-registry.d.ts.map

package/dist/tools/bash-internals.d.ts

@@ -0,0 +1,5 @@
+import { spawn } from "node:child_process";
+export declare function isErrnoException(error: unknown): error is NodeJS.ErrnoException;
+export declare function stripAnsiAndControls(s: string): string;
+export declare function killProcessGroup(child: ReturnType<typeof spawn>, isWindows: boolean, signal?: NodeJS.Signals): void;
+//# sourceMappingURL=bash-internals.d.ts.map

package/dist/tools/bash-output-tool.d.ts

@@ -0,0 +1,20 @@
+import type { BackgroundProcessRegistry } from "./background-process-registry.ts";
+export interface BashOutputToolOptions {
+    registry: BackgroundProcessRegistry;
+}
+export declare function createBashOutputTool(options: BashOutputToolOptions): import("../shared/types.ts").ToolDefinition<{
+    shellId: string;
+    regex?: string | undefined;
+}, never, import("../shared/types.ts").ToolOutputEnvelope, {
+    type: "object";
+    properties: {
+        shellId: {
+            type: "string";
+        };
+        regex: {
+            type: "string";
+        };
+    };
+    required: readonly ["shellId"];
+}>;
+//# sourceMappingURL=bash-output-tool.d.ts.map

package/dist/tools/bash-tool.d.ts

@@ -0,0 +1,75 @@
+import type { BackgroundProcessRegistry } from "./background-process-registry.ts";
+export interface BashToolInput {
+    command: string;
+    cwd?: string;
+    timeoutMs?: number;
+    ignoreOutput?: boolean;
+    runInBackground?: boolean;
+}
+export interface BashToolOptions {
+    allowedDirs?: readonly string[];
+    defaultCwd?: string;
+    defaultTimeoutMs?: number;
+    description?: string;
+    env?: NodeJS.ProcessEnv;
+    name?: string;
+    shellPath?: string;
+    stripAnsi?: boolean;
+    scrubEnvKeys?: readonly string[];
+    backgroundRegistry?: BackgroundProcessRegistry;
+}
+export declare function createBashTool(options?: BashToolOptions): import("../shared/types.ts").ToolDefinition<{
+    command: string;
+    timeoutMs?: number | undefined;
+    cwd?: string | undefined;
+    ignoreOutput?: boolean | undefined;
+    runInBackground?: boolean | undefined;
+}, string, import("../shared/types.ts").ToolOutputEnvelope, {
+    type: "object";
+    properties: {
+        command: {
+            type: "string";
+        };
+        cwd: {
+            type: "string";
+        };
+        timeoutMs: {
+            type: "number";
+        };
+        ignoreOutput: {
+            type: "boolean";
+        };
+        runInBackground: {
+            type: "boolean";
+        };
+    };
+    required: readonly ["command"];
+}>;
+export declare function createShellExecTool(options?: BashToolOptions): import("../shared/types.ts").ToolDefinition<{
+    command: string;
+    timeoutMs?: number | undefined;
+    cwd?: string | undefined;
+    ignoreOutput?: boolean | undefined;
+    runInBackground?: boolean | undefined;
+}, string, import("../shared/types.ts").ToolOutputEnvelope, {
+    type: "object";
+    properties: {
+        command: {
+            type: "string";
+        };
+        cwd: {
+            type: "string";
+        };
+        timeoutMs: {
+            type: "number";
+        };
+        ignoreOutput: {
+            type: "boolean";
+        };
+        runInBackground: {
+            type: "boolean";
+        };
+    };
+    required: readonly ["command"];
+}>;
+//# sourceMappingURL=bash-tool.d.ts.map

package/dist/tools/command-tool.d.ts

@@ -0,0 +1,23 @@
+import type { CommandDefinitionReference, SerializedCommandDefinition } from "@nuvin/config";
+export type CommandReference = CommandDefinitionReference;
+export type LoadedCommand = SerializedCommandDefinition;
+export interface CommandToolOptions<TRef extends CommandReference = CommandReference> {
+    commands: TRef[];
+    loadCommand: (reference: TRef) => Promise<LoadedCommand>;
+}
+export declare function createInvokeCommandTool<TRef extends CommandReference>(options: CommandToolOptions<TRef>): import("../shared/types.ts").ToolDefinition<{
+    name: string;
+    args?: string | undefined;
+}, import("../shared/types.ts").ToolOutputEnvelope, undefined, {
+    type: "object";
+    properties: {
+        name: {
+            type: "string";
+        };
+        args: {
+            type: "string";
+        };
+    };
+    required: readonly ["name"];
+}>;
+//# sourceMappingURL=command-tool.d.ts.map

package/dist/tools/file-edit-tool.d.ts

@@ -0,0 +1,29 @@
+export interface FileEditToolOptions {
+    allowedDirs?: readonly string[];
+    defaultCwd?: string;
+    name?: string;
+}
+export declare function createFileEditTool(options?: FileEditToolOptions): import("../shared/types.ts").ToolDefinition<{
+    filePath: string;
+    oldText: string;
+    newText: string;
+    dryRun?: boolean | undefined;
+}, import("../shared/types.ts").ToolOutputEnvelope, undefined, {
+    type: "object";
+    properties: {
+        filePath: {
+            type: "string";
+        };
+        oldText: {
+            type: "string";
+        };
+        newText: {
+            type: "string";
+        };
+        dryRun: {
+            type: "boolean";
+        };
+    };
+    required: readonly ["filePath", "oldText", "newText"];
+}>;
+//# sourceMappingURL=file-edit-tool.d.ts.map

package/dist/tools/file-new-tool.d.ts

@@ -0,0 +1,21 @@
+export interface FileNewToolOptions {
+    allowedDirs?: readonly string[];
+    defaultCwd?: string;
+    name?: string;
+}
+export declare function createFileNewTool(options?: FileNewToolOptions): import("../shared/types.ts").ToolDefinition<{
+    content: string;
+    filePath: string;
+}, import("../shared/types.ts").ToolOutputEnvelope, undefined, {
+    type: "object";
+    properties: {
+        filePath: {
+            type: "string";
+        };
+        content: {
+            type: "string";
+        };
+    };
+    required: readonly ["filePath", "content"];
+}>;
+//# sourceMappingURL=file-new-tool.d.ts.map

package/dist/tools/file-read-tool.d.ts

@@ -0,0 +1,27 @@
+export interface FileReadToolOptions {
+    allowedDirs?: readonly string[];
+    defaultCwd?: string;
+    name?: string;
+}
+export declare function createFileReadTool(options?: FileReadToolOptions): import("../shared/types.ts").ToolDefinition<{
+    path: string;
+    lineStart?: number | undefined;
+    lineEnd?: number | undefined;
+}, import("../shared/types.ts").ToolOutputEnvelope, undefined, {
+    type: "object";
+    properties: {
+        path: {
+            type: "string";
+        };
+        lineStart: {
+            type: "number";
+            description: string;
+        };
+        lineEnd: {
+            type: "number";
+            description: string;
+        };
+    };
+    required: readonly ["path"];
+}>;
+//# sourceMappingURL=file-read-tool.d.ts.map

package/dist/tools/glob-tool.d.ts

@@ -0,0 +1,26 @@
+export interface GlobToolOptions {
+    allowedDirs?: readonly string[];
+    defaultCwd?: string;
+    limit?: number;
+    name?: string;
+}
+export declare function createGlobTool(options?: GlobToolOptions): import("../shared/types.ts").ToolDefinition<{
+    pattern: string;
+    path?: string | undefined;
+    limit?: number | undefined;
+}, import("../shared/types.ts").ToolOutputEnvelope, undefined, {
+    type: "object";
+    properties: {
+        pattern: {
+            type: "string";
+        };
+        path: {
+            type: "string";
+        };
+        limit: {
+            type: "number";
+        };
+    };
+    required: readonly ["pattern"];
+}>;
+//# sourceMappingURL=glob-tool.d.ts.map

package/dist/tools/grep-tool.d.ts

@@ -0,0 +1,34 @@
+export interface GrepToolOptions {
+    allowedDirs?: readonly string[];
+    defaultCwd?: string;
+    limit?: number;
+    name?: string;
+}
+export declare function createGrepTool(options?: GrepToolOptions): import("../shared/types.ts").ToolDefinition<{
+    pattern: string;
+    include?: string | undefined;
+    path?: string | undefined;
+    limit?: number | undefined;
+    context?: number | undefined;
+}, import("../shared/types.ts").ToolOutputEnvelope, undefined, {
+    type: "object";
+    properties: {
+        pattern: {
+            type: "string";
+        };
+        path: {
+            type: "string";
+        };
+        include: {
+            type: "string";
+        };
+        limit: {
+            type: "number";
+        };
+        context: {
+            type: "number";
+        };
+    };
+    required: readonly ["pattern"];
+}>;
+//# sourceMappingURL=grep-tool.d.ts.map