ruvector 0.2.32 → 0.2.34

package/src/optimizer/settings-generator.js

@@ -0,0 +1,176 @@
+/**
+ * Settings generator — produces optimal .claude/settings.json for a
+ * given task profile. Based on decompiled Claude Code v2.1.91 schema.
+ *
+ * The generated settings include:
+ * - Permission mode matching the task type
+ * - Hooks for RVAgent integration (pre-task optimise, post-session learn)
+ * - Feature flags (thinking, fast mode, auto-compact, checkpointing)
+ */
+
+'use strict';
+
+/**
+ * Generate a complete settings.json object for a given profile.
+ *
+ * @param {object} profile
+ * @param {string} profile.taskType       - one of the known task types
+ * @param {string} profile.permissionMode - permission mode for this task
+ * @param {string} [profile.description]  - human-readable description
+ * @param {object} [profile.env]          - environment variables
+ * @returns {object} A settings.json-compatible object
+ */
+function generateSettings(profile) {
+  if (!profile || !profile.taskType) {
+    throw new Error('profile.taskType is required');
+  }
+
+  const isInteractive = !['ci', 'background'].includes(profile.taskType);
+  const needsThinking = ['planning', 'research', 'coding'].includes(profile.taskType);
+  const isFast = ['quickfix', 'ci'].includes(profile.taskType);
+
+  const settings = {
+    permissions: {
+      defaultMode: profile.permissionMode || 'default',
+    },
+    autoCompactEnabled: true,
+    fileCheckpointingEnabled: true,
+    promptSuggestionEnabled: isInteractive,
+  };
+
+  if (needsThinking) {
+    settings.alwaysThinkingEnabled = true;
+  }
+
+  if (isFast) {
+    settings.fastMode = true;
+  }
+
+  // Hooks for RVAgent integration
+  settings.hooks = buildHooks(profile.taskType);
+
+  return settings;
+}
+
+/**
+ * Build the hooks section for a given task type.
+ *
+ * @param {string} taskType
+ * @returns {object}
+ */
+function buildHooks(taskType) {
+  const hooks = {};
+
+  // Pre-tool-use hook: optimise before file-mutating tools
+  hooks.PreToolUse = [
+    {
+      matcher: 'Bash|Edit|Write',
+      hooks: [
+        {
+          type: 'command',
+          command: 'npx @claude-flow/cli@latest hooks pre-task --optimize',
+        },
+      ],
+    },
+  ];
+
+  // Post-session hook: persist learnings
+  hooks.Stop = [
+    {
+      matcher: '',
+      hooks: [
+        {
+          type: 'command',
+          command: 'npx @claude-flow/cli@latest hooks session-end --learn',
+        },
+      ],
+    },
+  ];
+
+  // Swarm tasks get an additional session-start hook for team discovery
+  if (taskType === 'swarm') {
+    hooks.SessionStart = [
+      {
+        matcher: '',
+        hooks: [
+          {
+            type: 'command',
+            command: 'npx @claude-flow/cli@latest hooks session-start --optimize --team',
+          },
+        ],
+      },
+    ];
+  }
+
+  return hooks;
+}
+
+/**
+ * Merge generated settings into an existing settings object, preserving
+ * user customisations that do not conflict.
+ *
+ * @param {object} existing - the current settings.json content
+ * @param {object} generated - output from generateSettings()
+ * @returns {object} merged settings
+ */
+function mergeSettings(existing, generated) {
+  if (!existing) return generated;
+
+  const merged = { ...existing };
+
+  // Merge permissions
+  merged.permissions = {
+    ...(existing.permissions || {}),
+    ...(generated.permissions || {}),
+  };
+
+  // Merge hooks (append, do not replace)
+  if (generated.hooks) {
+    merged.hooks = merged.hooks || {};
+    for (const [event, hookList] of Object.entries(generated.hooks)) {
+      const existingHooks = merged.hooks[event] || [];
+      // Avoid duplicates by checking command strings
+      const existingCmds = new Set(
+        existingHooks.flatMap((h) =>
+          (h.hooks || []).map((inner) => inner.command)
+        )
+      );
+      const newHooks = hookList.filter((h) =>
+        (h.hooks || []).some((inner) => !existingCmds.has(inner.command))
+      );
+      merged.hooks[event] = [...existingHooks, ...newHooks];
+    }
+  }
+
+  // Copy feature flags (generated wins)
+  for (const key of [
+    'autoCompactEnabled',
+    'fileCheckpointingEnabled',
+    'promptSuggestionEnabled',
+    'alwaysThinkingEnabled',
+    'fastMode',
+  ]) {
+    if (generated[key] !== undefined) {
+      merged[key] = generated[key];
+    }
+  }
+
+  return merged;
+}
+
+/**
+ * Serialise settings to a formatted JSON string.
+ *
+ * @param {object} settings
+ * @returns {string}
+ */
+function formatSettings(settings) {
+  return JSON.stringify(settings, null, 2);
+}
+
+module.exports = {
+  generateSettings,
+  buildHooks,
+  mergeSettings,
+  formatSettings,
+};

package/src/optimizer/tool-schemas.js

@@ -0,0 +1,190 @@
+/**
+ * Decompiled tool schemas from Claude Code v2.1.91.
+ *
+ * These schemas mirror the exact inputSchema definitions found in the
+ * decompiled binary. They enable Tier-1 (WASM booster) validation of
+ * tool calls without invoking the LLM, and provide a known-pattern
+ * cache for deterministic tool responses.
+ */
+
+'use strict';
+
+/**
+ * Tool input schemas extracted from decompiled Claude Code v2.1.91.
+ * A trailing '?' on the type string means the field is optional.
+ */
+const TOOL_SCHEMAS = {
+  Bash: {
+    command: 'string',
+    description: 'string?',
+    timeout: 'number?',
+    run_in_background: 'boolean?',
+  },
+  Read: {
+    file_path: 'string',
+    offset: 'number?',
+    limit: 'number?',
+    pages: 'string?',
+  },
+  Edit: {
+    file_path: 'string',
+    old_string: 'string',
+    new_string: 'string',
+    replace_all: 'boolean?',
+  },
+  Write: {
+    file_path: 'string',
+    content: 'string',
+  },
+  Glob: {
+    pattern: 'string',
+    path: 'string?',
+  },
+  Grep: {
+    pattern: 'string',
+    path: 'string?',
+    glob: 'string?',
+    type: 'string?',
+    output_mode: 'string?',
+    '-i': 'boolean?',
+    '-n': 'boolean?',
+    '-A': 'number?',
+    '-B': 'number?',
+    '-C': 'number?',
+    context: 'number?',
+    head_limit: 'number?',
+    offset: 'number?',
+    multiline: 'boolean?',
+  },
+  Agent: {
+    prompt: 'string',
+    description: 'string?',
+  },
+  WebFetch: {
+    url: 'string',
+  },
+  WebSearch: {
+    query: 'string',
+  },
+  TodoWrite: {
+    todos: 'array',
+  },
+  NotebookEdit: {
+    notebook_path: 'string',
+    cell_number: 'number',
+    new_source: 'string',
+    cell_type: 'string?',
+  },
+  ToolSearch: {
+    query: 'string',
+    max_results: 'number?',
+  },
+  Skill: {
+    skill: 'string',
+    args: 'string?',
+  },
+  EnterWorktree: {
+    name: 'string?',
+    branch: 'string?',
+    path: 'string?',
+  },
+  ExitWorktree: {
+    name: 'string?',
+  },
+};
+
+/** All known tool names. */
+const TOOL_NAMES = Object.keys(TOOL_SCHEMAS);
+
+/** Base type checkers for schema validation. */
+const TYPE_CHECKS = {
+  string: (v) => typeof v === 'string',
+  number: (v) => typeof v === 'number' && !Number.isNaN(v),
+  boolean: (v) => typeof v === 'boolean',
+  array: (v) => Array.isArray(v),
+  object: (v) => v !== null && typeof v === 'object' && !Array.isArray(v),
+};
+
+/**
+ * Validate a tool call's arguments against the known schema.
+ * Returns { valid: true } or { valid: false, errors: string[] }.
+ *
+ * This is intended as a fast Tier-1 check — it validates structure
+ * without calling any LLM. Unknown tool names pass validation
+ * (we assume they are custom MCP tools).
+ *
+ * @param {string} toolName
+ * @param {object} args
+ * @returns {{ valid: boolean, errors?: string[] }}
+ */
+function validateToolCall(toolName, args) {
+  const schema = TOOL_SCHEMAS[toolName];
+  if (!schema) {
+    // Unknown tool — let it through (may be an MCP extension)
+    return { valid: true };
+  }
+
+  if (!args || typeof args !== 'object') {
+    return { valid: false, errors: ['args must be a non-null object'] };
+  }
+
+  const errors = [];
+
+  for (const [field, typeSpec] of Object.entries(schema)) {
+    const isOptional = typeSpec.endsWith('?');
+    const baseType = isOptional ? typeSpec.slice(0, -1) : typeSpec;
+    const value = args[field];
+
+    if (value === undefined || value === null) {
+      if (!isOptional) {
+        errors.push(`Missing required field: ${field}`);
+      }
+      continue;
+    }
+
+    const checker = TYPE_CHECKS[baseType];
+    if (checker && !checker(value)) {
+      errors.push(`Field '${field}' expected ${baseType}, got ${typeof value}`);
+    }
+  }
+
+  return errors.length === 0
+    ? { valid: true }
+    : { valid: false, errors };
+}
+
+/**
+ * Cached patterns for common tool calls that produce deterministic
+ * or near-deterministic results. The booster can skip LLM calls
+ * entirely for these patterns.
+ */
+const CACHED_PATTERNS = {
+  'Glob:**/*.ts': { pattern: '**/*.ts' },
+  'Glob:**/*.js': { pattern: '**/*.js' },
+  'Glob:**/*.py': { pattern: '**/*.py' },
+  'Glob:**/*.rs': { pattern: '**/*.rs' },
+  'Glob:**/*.json': { pattern: '**/*.json' },
+  'Glob:package.json': { pattern: '**/package.json' },
+  'Glob:Cargo.toml': { pattern: '**/Cargo.toml' },
+  'Grep:import.*from': { pattern: 'import.*from', type: 'js' },
+  'Grep:use ': { pattern: '^use ', type: 'rust' },
+  'Grep:TODO|FIXME': { pattern: 'TODO|FIXME' },
+};
+
+/**
+ * Look up a cached pattern. Returns the pattern args or null.
+ * @param {string} toolName
+ * @param {string} shortKey - a short identifier for the pattern
+ * @returns {object|null}
+ */
+function getCachedPattern(toolName, shortKey) {
+  return CACHED_PATTERNS[`${toolName}:${shortKey}`] || null;
+}
+
+module.exports = {
+  TOOL_SCHEMAS,
+  TOOL_NAMES,
+  validateToolCall,
+  CACHED_PATTERNS,
+  getCachedPattern,
+};

package/wasm/package.json

@@ -1,27 +1,27 @@
-{
-  "name": "ruvector-decompiler-wasm",
-  "collaborators": [
-    "Ruvector Team"
-  ],
-  "description": "WASM bindings for the RuVector JavaScript bundle decompiler (Louvain pipeline)",
-  "version": "2.1.0",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/ruvnet/ruvector"
-  },
-  "files": [
-    "ruvector_decompiler_wasm_bg.wasm",
-    "ruvector_decompiler_wasm.js",
-    "ruvector_decompiler_wasm.d.ts"
-  ],
-  "main": "ruvector_decompiler_wasm.js",
-  "types": "ruvector_decompiler_wasm.d.ts",
-  "keywords": [
-    "decompiler",
-    "javascript",
-    "wasm",
-    "mincut",
-    "louvain"
-  ]
+{
+  "name": "ruvector-decompiler-wasm",
+  "collaborators": [
+    "Ruvector Team"
+  ],
+  "description": "WASM bindings for the RuVector JavaScript bundle decompiler (Louvain pipeline)",
+  "version": "2.1.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ruvnet/ruvector"
+  },
+  "files": [
+    "ruvector_decompiler_wasm_bg.wasm",
+    "ruvector_decompiler_wasm.js",
+    "ruvector_decompiler_wasm.d.ts"
+  ],
+  "main": "ruvector_decompiler_wasm.js",
+  "types": "ruvector_decompiler_wasm.d.ts",
+  "keywords": [
+    "decompiler",
+    "javascript",
+    "wasm",
+    "mincut",
+    "louvain"
+  ]
 }

package/wasm/ruvector_decompiler_wasm.d.ts

@@ -1,27 +1,27 @@
-/* tslint:disable */
-/* eslint-disable */
-
-/**
- * Decompile a minified JavaScript bundle using the full Louvain pipeline.
- *
- * # Arguments
- *
- * * `source` - The minified JavaScript source code.
- * * `config_json` - JSON string of `DecompileConfig` fields. Pass `"{}"` for defaults.
- *
- * # Returns
- *
- * A JSON string containing the `DecompileResult` (modules, witness, inferred names, etc.)
- * or a JSON object with an `"error"` field on failure.
- */
-export function decompile(source: string, config_json: string): string;
-
-/**
- * Initialize the WASM module (sets up panic hook for better error messages).
- */
-export function init(): void;
-
-/**
- * Return the version of the decompiler WASM module.
- */
-export function version(): string;
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Decompile a minified JavaScript bundle using the full Louvain pipeline.
+ *
+ * # Arguments
+ *
+ * * `source` - The minified JavaScript source code.
+ * * `config_json` - JSON string of `DecompileConfig` fields. Pass `"{}"` for defaults.
+ *
+ * # Returns
+ *
+ * A JSON string containing the `DecompileResult` (modules, witness, inferred names, etc.)
+ * or a JSON object with an `"error"` field on failure.
+ */
+export function decompile(source: string, config_json: string): string;
+
+/**
+ * Initialize the WASM module (sets up panic hook for better error messages).
+ */
+export function init(): void;
+
+/**
+ * Return the version of the decompiler WASM module.
+ */
+export function version(): string;