@pellux/goodvibes-tui 0.18.11 → 0.18.13

package/src/tools/remote-trigger/index.ts

@@ -1,130 +0,0 @@
-import type { Tool } from '@pellux/goodvibes-sdk/platform/types/tools';
-import { RemoteRunnerRegistry } from '@pellux/goodvibes-sdk/platform/runtime/remote/runner-registry';
-import { REMOTE_TRIGGER_TOOL_SCHEMA, type RemoteTriggerToolInput } from '@pellux/goodvibes-sdk/platform/tools/remote-trigger/schema';
-
-function summarizePool(pool: ReturnType<RemoteRunnerRegistry['listPools']>[number]) {
-  return {
-    id: pool.id,
-    label: pool.label,
-    runnerCount: pool.runnerIds.length,
-    runnerIds: pool.runnerIds,
-    updatedAt: pool.lastUpdatedAt,
-  };
-}
-
-function summarizeContract(contract: ReturnType<RemoteRunnerRegistry['listContracts']>[number]) {
-  return {
-    id: contract.id,
-    runnerId: contract.runnerId,
-    label: contract.label,
-    sourceTransport: contract.sourceTransport,
-    trustClass: contract.trustClass,
-    template: contract.template,
-    transportState: contract.transport.state,
-    toolCount: contract.capabilityCeiling.allowedTools.length,
-    reviewMode: contract.capabilityCeiling.reviewMode,
-    communicationLane: contract.capabilityCeiling.communicationLane,
-  };
-}
-
-function summarizeArtifact(artifact: ReturnType<RemoteRunnerRegistry['listArtifacts']>[number]) {
-  return {
-    id: artifact.id,
-    runnerId: artifact.runnerId,
-    createdAt: artifact.createdAt,
-    task: artifact.task.task,
-    status: artifact.task.status,
-    hasKnowledgeInjections: artifact.knowledgeInjections.length > 0,
-  };
-}
-
-export function createRemoteTool(registry: RemoteRunnerRegistry): Tool {
-  return {
-    definition: {
-      name: 'remote',
-      description: 'Manage remote runner pools, contracts, and portable artifacts.',
-      parameters: REMOTE_TRIGGER_TOOL_SCHEMA.parameters,
-      sideEffects: ['workflow', 'state'],
-      concurrency: 'serial',
-    },
-
-    async execute(args: Record<string, unknown>) {
-      if (!args || typeof args !== 'object' || typeof args.mode !== 'string') {
-        return { success: false, error: 'Invalid args: mode is required.' };
-      }
-      const input = args as unknown as RemoteTriggerToolInput;
-      const view = input.view ?? 'summary';
-
-      if (input.mode === 'create-pool') {
-        if (!input.poolId) return { success: false, error: 'create-pool requires poolId.' };
-        const pool = registry.createPool({ id: input.poolId, label: input.label });
-        return { success: true, output: JSON.stringify(pool) };
-      }
-
-      if (input.mode === 'pools') {
-        const pools = registry.listPools();
-        return {
-          success: true,
-          output: JSON.stringify({
-            view,
-            count: pools.length,
-            pools: view === 'full' ? pools : pools.map(summarizePool),
-          }),
-        };
-      }
-
-      if (input.mode === 'assign') {
-        if (!input.poolId || !input.runnerId) return { success: false, error: 'assign requires poolId and runnerId.' };
-        const pool = registry.assignRunnerToPool(input.poolId, input.runnerId);
-        if (!pool) return { success: false, error: `Unable to assign ${input.runnerId} to ${input.poolId}` };
-        return { success: true, output: JSON.stringify(pool) };
-      }
-
-      if (input.mode === 'unassign') {
-        if (!input.poolId || !input.runnerId) return { success: false, error: 'unassign requires poolId and runnerId.' };
-        const pool = registry.removeRunnerFromPool(input.poolId, input.runnerId);
-        if (!pool) return { success: false, error: `Unknown pool: ${input.poolId}` };
-        return { success: true, output: JSON.stringify(pool) };
-      }
-
-      if (input.mode === 'contracts') {
-        const contracts = registry.listContracts();
-        return {
-          success: true,
-          output: JSON.stringify({
-            view,
-            count: contracts.length,
-            contracts: view === 'full' ? contracts : contracts.map(summarizeContract),
-          }),
-        };
-      }
-
-      if (input.mode === 'artifacts') {
-        const artifacts = registry.listArtifacts();
-        return {
-          success: true,
-          output: JSON.stringify({
-            view,
-            count: artifacts.length,
-            artifacts: view === 'full' ? artifacts : artifacts.map(summarizeArtifact),
-          }),
-        };
-      }
-
-      if (input.mode === 'review') {
-        if (!input.artifactId) return { success: false, error: 'review requires artifactId.' };
-        const summary = registry.buildReviewSummary(input.artifactId);
-        if (!summary) return { success: false, error: `Unknown artifact: ${input.artifactId}` };
-        return { success: true, output: summary };
-      }
-
-      if (input.mode === 'import-artifact') {
-        if (!input.path) return { success: false, error: 'import-artifact requires path.' };
-        const artifact = await registry.importArtifact(input.path);
-        return { success: true, output: JSON.stringify(artifact) };
-      }
-
-      return { success: false, error: `Unknown mode: ${input.mode}` };
-    },
-  };
-}

package/src/tools/shared/auto-heal.ts

@@ -1,282 +0,0 @@
-/**
- * AutoHealer — three-stage pipeline to fix write/edit validation failures.
- *
- * Pipeline (opt-in via tools.autoHeal config):
- *   1. Formatter: prettier --write or biome format
- *   2. Linter fix: eslint --fix
- *   3. ToolLLM: LLM-assisted fix with error context
- *
- * Design constraints:
- *   - Never throws — returns {healed: false, content: originalContent} on any failure
- *   - Each stage checks if errors are resolved before proceeding to the next
- *   - Uses Bun.which() to detect available tools at runtime
- */
-
-import { writeFileSync, readFileSync, unlinkSync, existsSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join, extname } from 'node:path';
-import { randomBytes } from 'node:crypto';
-import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config/manager';
-import type { ToolLLM } from '@pellux/goodvibes-sdk/platform/config/tool-llm';
-import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
-
-/** Result of an auto-heal attempt. */
-export interface HealResult {
-  healed: boolean;
-  content: string;
-  method?: 'formatter' | 'linter' | 'llm';
-}
-
-/**
- * AutoHealer — attempts to fix content with validation errors via a staged pipeline.
- *
- * Usage:
- *   const healer = new AutoHealer();
- *   const result = await healer.heal(filePath, content, errors);
- *   if (result.healed) { // use result.content }
- */
-export class AutoHealer {
-  constructor(
-    private readonly configManager: Pick<ConfigManager, 'get'>,
-    private readonly toolLLM: Pick<ToolLLM, 'chat'>,
-  ) {}
-
-  /**
-   * Attempt to auto-heal content with validation errors.
-   *
-   * @param filePath     Original file path (used to determine extension/context).
-   * @param content      File content that failed validation.
-   * @param errors       Validation error messages from the failed write/edit.
-   * @returns            Heal result — healed=true means content was fixed.
-   */
-  async heal(filePath: string, content: string, errors: string[]): Promise<HealResult> {
-    try {
-      // Config gate: only run when tools.autoHeal is enabled
-      if (!this.configManager.get('tools.autoHeal')) {
-        return { healed: false, content };
-      }
-
-      if (!errors.length) {
-        return { healed: false, content };
-      }
-
-      const ext = extname(filePath) || '.txt';
-      const tmpFile = join(tmpdir(), `auto-heal-${randomBytes(6).toString('hex')}${ext}`);
-
-      try {
-        // Stage 1: Formatter
-        const formatterResult = await this._tryFormatter(tmpFile, content, errors);
-        if (formatterResult.healed) {
-          return formatterResult;
-        }
-
-        // Stage 2: Linter fix
-        const linterResult = await this._tryLinter(tmpFile, formatterResult.content, errors);
-        if (linterResult.healed) {
-          return linterResult;
-        }
-
-        // Stage 3: ToolLLM
-        const llmResult = await this._tryLLM(filePath, linterResult.content, errors);
-        return llmResult;
-      } finally {
-        // Clean up temp file
-        try {
-          if (existsSync(tmpFile)) {
-            unlinkSync(tmpFile);
-          }
-        } catch {
-          // Ignore cleanup errors
-        }
-      }
-    } catch (err) {
-      logger.debug('AutoHealer.heal: unexpected error (non-fatal)', { error: summarizeError(err) });
-      return { healed: false, content };
-    }
-  }
-
-  /**
-   * Stage 1: Try formatting with prettier or biome.
-   */
-  private async _tryFormatter(tmpFile: string, content: string, errors: string[]): Promise<HealResult> {
-    try {
-      const prettier = Bun.which('prettier');
-      const biome = Bun.which('biome');
-
-      if (!prettier && !biome) {
-        logger.debug('AutoHealer: no formatter found (prettier/biome), skipping stage 1');
-        return { healed: false, content };
-      }
-
-      // Write content to temp file
-      writeFileSync(tmpFile, content, 'utf-8');
-
-      let proc: { exitCode: number | null };
-
-      if (prettier) {
-        proc = Bun.spawnSync([prettier, '--write', '--log-level', 'silent', tmpFile]);
-      } else {
-        // biome format --write
-        proc = Bun.spawnSync([biome!, 'format', '--write', tmpFile], {
-          stderr: 'pipe',
-        });
-      }
-
-      if (proc.exitCode !== 0) {
-        logger.debug('AutoHealer: formatter exited non-zero, skipping stage 1');
-        return { healed: false, content };
-      }
-
-      const formatted = readFileSync(tmpFile, 'utf-8');
-
-      if (formatted === content) {
-        // Formatter made no changes — errors not formatter-related
-        return { healed: false, content };
-      }
-
-      // Check if errors appear resolved (heuristic: no syntax errors after format)
-      const resolved = await this._errorsResolved(tmpFile, errors);
-      if (resolved) {
-        logger.debug('AutoHealer: errors resolved by formatter');
-        return { healed: true, content: formatted, method: 'formatter' };
-      }
-
-      // Formatter ran but errors remain — pass updated content to next stage
-      return { healed: false, content: formatted };
-    } catch (err) {
-      logger.debug('AutoHealer: formatter stage failed (non-fatal)', { error: summarizeError(err) });
-      return { healed: false, content };
-    }
-  }
-
-  /**
-   * Stage 2: Try linter fix with eslint.
-   */
-  private async _tryLinter(tmpFile: string, content: string, errors: string[]): Promise<HealResult> {
-    try {
-      const eslint = Bun.which('eslint');
-
-      if (!eslint) {
-        logger.debug('AutoHealer: eslint not found, skipping stage 2');
-        return { healed: false, content };
-      }
-
-      // Write (possibly formatter-updated) content to temp file
-      writeFileSync(tmpFile, content, 'utf-8');
-
-      const proc = Bun.spawnSync([eslint, '--fix', tmpFile], {
-        stderr: 'pipe',
-        stdout: 'pipe',
-      });
-
-      // eslint --fix exits 1 on remaining errors, 0 on clean — both are acceptable
-      const fixed = readFileSync(tmpFile, 'utf-8');
-
-      if (fixed === content) {
-        return { healed: false, content };
-      }
-
-      const resolved = await this._errorsResolved(tmpFile, errors);
-      if (resolved) {
-        logger.debug('AutoHealer: errors resolved by linter');
-        return { healed: true, content: fixed, method: 'linter' };
-      }
-
-      return { healed: false, content: fixed };
-    } catch (err) {
-      logger.debug('AutoHealer: linter stage failed (non-fatal)', { error: summarizeError(err) });
-      return { healed: false, content };
-    }
-  }
-
-  /**
-   * Stage 3: Try ToolLLM with error context.
-   */
-  private async _tryLLM(filePath: string, content: string, errors: string[]): Promise<HealResult> {
-    try {
-      const errorList = errors.map((e, i) => `${i + 1}. ${e}`).join('\n');
-      const prompt = [
-        `You are a code repair assistant. The following file has validation errors that need to be fixed.`,
-        ``,
-        `File: ${filePath}`,
-        ``,
-        `Errors:`,
-        errorList,
-        ``,
-        `Current content:`,
-        `\`\`\``,
-        content,
-        `\`\`\``,
-        ``,
-        `Return ONLY the corrected file content, no explanation, no markdown fences.`,
-      ].join('\n');
-
-      const response = await this.toolLLM.chat(prompt, {
-        maxTokens: 4096,
-        systemPrompt: 'You are a code repair tool. Output only the corrected file content with no additional text or markdown.',
-      });
-
-      if (!response || response.trim() === '') {
-        logger.debug('AutoHealer: LLM returned empty response');
-        return { healed: false, content };
-      }
-
-      // Verify the LLM fix actually resolves errors
-      const llmTmpFile = join(tmpdir(), `auto-heal-llm-${randomBytes(6).toString('hex')}${extname(filePath) || '.txt'}`);
-      try {
-        writeFileSync(llmTmpFile, response, 'utf-8');
-        const resolved = await this._errorsResolved(llmTmpFile, errors);
-        if (!resolved) {
-          logger.debug('AutoHealer: LLM response did not resolve errors');
-          return { healed: false, content };
-        }
-      } finally {
-        try {
-          if (existsSync(llmTmpFile)) unlinkSync(llmTmpFile);
-        } catch {
-          // Ignore cleanup errors
-        }
-      }
-
-      logger.debug('AutoHealer: errors resolved by LLM');
-      return { healed: true, content: response, method: 'llm' };
-    } catch (err) {
-      logger.debug('AutoHealer: LLM stage failed (non-fatal)', { error: summarizeError(err) });
-      return { healed: false, content };
-    }
-  }
-
-  /**
-   * Heuristic check: attempt to parse/validate a temp file to see if errors are resolved.
-   *
-   * For JS/TS files: uses Bun's built-in transpiler to check for syntax errors.
-   * For other files: assumes resolved if formatter/linter succeeded (conservative).
-   */
-  private async _errorsResolved(tmpFile: string, _errors: string[]): Promise<boolean> {
-    try {
-      const ext = extname(tmpFile).toLowerCase();
-      const isJsTs = ['.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs'].includes(ext);
-
-      if (!isJsTs) {
-        // For non-JS/TS: trust the formatter/linter exit code
-        return true;
-      }
-
-      // For JS/TS: attempt transpile with Bun to catch syntax errors
-      const content = readFileSync(tmpFile, 'utf-8');
-      const loader = (ext === '.mjs' || ext === '.cjs') ? 'js' : ext.slice(1) as 'ts' | 'tsx' | 'js' | 'jsx';
-      const transpiler = new Bun.Transpiler({ loader });
-
-      try {
-        transpiler.transformSync(content);
-        return true;
-      } catch {
-        return false;
-      }
-    } catch {
-      // If we can't check, optimistically assume resolved
-      return true;
-    }
-  }
-}