vigthoria-cli 1.13.20 → 1.13.23

package/dist/utils/tool-approval-service.js

@@ -0,0 +1,78 @@
+import path from 'node:path';
+import { DurableJsonStore } from './durable-json.js';
+function normalizePermissionState(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    return Object.fromEntries(Object.entries(value).map(([workspace, entry]) => [workspace, {
+            operations: Array.isArray(entry?.operations) ? entry.operations : [],
+            updatedAt: String(entry?.updatedAt || ''),
+        }]));
+}
+export class ToolApprovalService {
+    workspace;
+    logger;
+    sessionOperations = new Set();
+    store;
+    constructor(workspace, logger, permissionsFile = path.join(process.env.HOME || process.env.USERPROFILE || '~', '.vigthoria', 'permissions.json')) {
+        this.workspace = workspace;
+        this.logger = logger;
+        this.store = new DurableJsonStore({
+            filePath: permissionsFile,
+            schemaVersion: 2,
+            defaultValue: () => ({}),
+            validate: (value) => Boolean(value && typeof value === 'object' && !Array.isArray(value)),
+            migrate: normalizePermissionState,
+        });
+    }
+    report(operation, error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        const message = `Approval state ${operation} failed: ${detail}`;
+        this.logger.debug(message);
+        this.logger.warn(message);
+    }
+    read() {
+        try {
+            return normalizePermissionState(this.store.read());
+        }
+        catch (error) {
+            this.report('read', error);
+            return {};
+        }
+    }
+    hasPersistent(scope) {
+        return this.read()[this.workspace]?.operations?.some((operation) => (operation.key === scope.key
+            && operation.tool === scope.tool
+            && operation.workspace === scope.workspace
+            && operation.destination === scope.destination)) || false;
+    }
+    hasSession(scope) {
+        return this.sessionOperations.has(scope.key);
+    }
+    recordSession(scope) {
+        this.sessionOperations.add(scope.key);
+    }
+    recordPersistent(scope) {
+        this.recordSession(scope);
+        try {
+            this.store.update((current) => {
+                const existing = normalizePermissionState(current)[this.workspace]?.operations || [];
+                const operations = existing.some((operation) => operation.key === scope.key)
+                    ? existing
+                    : [...existing, scope];
+                return {
+                    ...current,
+                    [this.workspace]: { operations, updatedAt: new Date().toISOString() },
+                };
+            });
+        }
+        catch (error) {
+            this.report('write', error);
+        }
+    }
+    clearSession() {
+        this.sessionOperations.clear();
+    }
+    sessionKeys() {
+        return [...this.sessionOperations];
+    }
+}

package/dist/utils/tool-capability-providers.d.ts

@@ -0,0 +1,57 @@
+export interface CapabilityToolCall {
+    tool: string;
+    args: Record<string, string>;
+}
+export interface CapabilityToolResult {
+    success: boolean;
+    output?: string;
+    error?: string;
+    suggestion?: string;
+    canRetry?: boolean;
+    undoable?: boolean;
+    dryRun?: boolean;
+    message?: string;
+    metadata?: Record<string, any>;
+}
+export type CapabilityHandler = (args: Record<string, string>) => CapabilityToolResult | Promise<CapabilityToolResult>;
+export interface ToolCapabilityProvider {
+    readonly name: string;
+    readonly tools: readonly string[];
+    execute(call: CapabilityToolCall): Promise<CapabilityToolResult>;
+}
+declare abstract class NamedToolProvider implements ToolCapabilityProvider {
+    readonly name: string;
+    private readonly handlers;
+    readonly tools: readonly string[];
+    constructor(name: string, handlers: Readonly<Record<string, CapabilityHandler>>);
+    execute(call: CapabilityToolCall): Promise<CapabilityToolResult>;
+}
+export declare class FilesystemToolProvider extends NamedToolProvider {
+    constructor(handlers: Readonly<Record<string, CapabilityHandler>>);
+}
+export declare class ProcessToolProvider extends NamedToolProvider {
+    constructor(handlers: Readonly<Record<string, CapabilityHandler>>);
+}
+export declare class SearchToolProvider extends NamedToolProvider {
+    constructor(handlers: Readonly<Record<string, CapabilityHandler>>);
+}
+export declare class RepositoryToolProvider extends NamedToolProvider {
+    constructor(handlers: Readonly<Record<string, CapabilityHandler>>);
+}
+export declare class NetworkBrowserToolProvider extends NamedToolProvider {
+    constructor(handlers: Readonly<Record<string, CapabilityHandler>>);
+}
+export declare class SshToolProvider extends NamedToolProvider {
+    constructor(handlers: Readonly<Record<string, CapabilityHandler>>);
+}
+export declare class DelegationToolProvider extends NamedToolProvider {
+    constructor(handlers: Readonly<Record<string, CapabilityHandler>>);
+}
+export declare class ToolCapabilityRegistry {
+    private readonly owners;
+    constructor(providers: ToolCapabilityProvider[]);
+    providerFor(tool: string): string | null;
+    toolNames(): string[];
+    execute(call: CapabilityToolCall): Promise<CapabilityToolResult>;
+}
+export {};

package/dist/utils/tool-capability-providers.js

@@ -0,0 +1,57 @@
+class NamedToolProvider {
+    name;
+    handlers;
+    tools;
+    constructor(name, handlers) {
+        this.name = name;
+        this.handlers = handlers;
+        this.tools = Object.freeze(Object.keys(handlers));
+    }
+    async execute(call) {
+        const handler = this.handlers[call.tool];
+        if (!handler)
+            return { success: false, error: `${this.name} provider does not implement ${call.tool}`, canRetry: false };
+        return handler(call.args);
+    }
+}
+export class FilesystemToolProvider extends NamedToolProvider {
+    constructor(handlers) { super('filesystem', handlers); }
+}
+export class ProcessToolProvider extends NamedToolProvider {
+    constructor(handlers) { super('process', handlers); }
+}
+export class SearchToolProvider extends NamedToolProvider {
+    constructor(handlers) { super('search', handlers); }
+}
+export class RepositoryToolProvider extends NamedToolProvider {
+    constructor(handlers) { super('repository', handlers); }
+}
+export class NetworkBrowserToolProvider extends NamedToolProvider {
+    constructor(handlers) { super('network-browser', handlers); }
+}
+export class SshToolProvider extends NamedToolProvider {
+    constructor(handlers) { super('ssh', handlers); }
+}
+export class DelegationToolProvider extends NamedToolProvider {
+    constructor(handlers) { super('delegation', handlers); }
+}
+export class ToolCapabilityRegistry {
+    owners = new Map();
+    constructor(providers) {
+        for (const provider of providers) {
+            for (const tool of provider.tools) {
+                if (this.owners.has(tool))
+                    throw new Error(`Tool capability ${tool} has multiple providers.`);
+                this.owners.set(tool, provider);
+            }
+        }
+    }
+    providerFor(tool) { return this.owners.get(tool)?.name || null; }
+    toolNames() { return [...this.owners.keys()].sort(); }
+    async execute(call) {
+        const provider = this.owners.get(call.tool);
+        if (!provider)
+            return { success: false, error: `Tool not implemented: ${call.tool}`, canRetry: false };
+        return provider.execute(call);
+    }
+}

package/dist/utils/tools.d.ts

@@ -82,37 +82,20 @@ export declare class AgenticTools {
     private cwd;
     private permissionCallback;
     private autoApprove;
+    private readonly approvals;
+    private readonly capabilityRegistry;
     private undoStack;
     private maxUndoStack;
     private retryConfig;
     private formatExternalToolError;
-    private externalToolFailure;
     private cleanupAfterToolError;
-    private runExternalCommand;
     private isNonEmptyString;
     private describeInvalidValue;
     private assertStringRecord;
-    private requireNonEmptyString;
-    private requireArgsObject;
-    private sessionApprovedTools;
-    private static permissionsFile;
     constructor(logger: Logger, cwd: string, permissionCallback: (action: string, options?: {
         batchApproval?: boolean;
     }) => Promise<boolean | 'batch' | 'persist'>, autoApprove?: boolean);
     private getErrorMessage;
-    private assertToolCall;
-    /**
-     * Load persistent permissions for the current project
-     */
-    private loadPersistentPermissions;
-    /**
-     * Save a persistent permission for a tool in the current project
-     */
-    private savePersistentPermission;
-    /**
-     * Check if a tool has persistent permission for the current project
-     */
-    private hasPersistentPermission;
     /**
      * Clear session-approved tools (call this at the start of each new AI turn)
      */
@@ -217,10 +200,6 @@ export declare class AgenticTools {
      * Search using ripgrep (rg) — works on all platforms
      */
     private grepWithRg;
-    /**
-     * Search using PowerShell Select-String (Windows)
-     */
-    private grepWithSelectString;
     /**
      * Pure Node.js recursive file search — reliable on all platforms, no external deps
      */