entroly-wasm 0.9.0

package/js/workspace.js

@@ -0,0 +1,116 @@
+/**
+ * Workspace Change Listener — pure-JS port of entroly/change_listener.py
+ * Detects file changes, marks beliefs stale, recompiles, verifies.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { SOURCE_EXTS } = require('./vault');
+
+class WorkspaceChangeListener {
+  constructor(vault, compiler, verifier, changePipe, projectDir) {
+    this._vault = vault;
+    this._compiler = compiler;
+    this._verifier = verifier;
+    this._changePipe = changePipe;
+    this._projectDir = projectDir || process.cwd();
+    this._lastScan = {};  // file -> mtime
+    this._watcher = null;
+    this._running = false;
+  }
+
+  scanOnce(force = false, maxFiles = 100) {
+    const changes = { new: [], modified: [], deleted: [] };
+    const currentFiles = {};
+    const walk = (dir, depth = 0) => {
+      if (depth > 8) return;
+      let entries;
+      try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+      for (const e of entries) {
+        if (e.name.startsWith('.') || e.name === 'node_modules' || e.name === '__pycache__' || e.name === 'target') continue;
+        const full = path.join(dir, e.name);
+        if (e.isDirectory()) { walk(full, depth + 1); continue; }
+        if (!SOURCE_EXTS.has(path.extname(e.name))) continue;
+        try {
+          const stat = fs.statSync(full);
+          const mtime = stat.mtimeMs;
+          const rel = path.relative(this._projectDir, full).replace(/\\/g, '/');
+          currentFiles[rel] = mtime;
+          if (!this._lastScan[rel]) changes.new.push(rel);
+          else if (force || mtime > this._lastScan[rel]) changes.modified.push(rel);
+        } catch {}
+      }
+    };
+    walk(this._projectDir);
+
+    // Detect deletions
+    for (const rel of Object.keys(this._lastScan)) {
+      if (!currentFiles[rel]) changes.deleted.push(rel);
+    }
+    this._lastScan = currentFiles;
+
+    const allChanged = [...changes.new, ...changes.modified].slice(0, maxFiles);
+    let beliefsStaled = 0, beliefsRecompiled = 0;
+
+    if (allChanged.length > 0) {
+      const staleResult = this._vault.markBeliefsStaleForFiles(allChanged);
+      beliefsStaled = staleResult.updated_entities ? staleResult.updated_entities.length : 0;
+
+      // Recompile changed files
+      for (const rel of allChanged.slice(0, 20)) {
+        try {
+          const fp = path.join(this._projectDir, rel);
+          if (fs.existsSync(fp)) {
+            const dir = path.dirname(fp);
+            const result = this._compiler.compileDirectory(dir, 1);
+            beliefsRecompiled += result.beliefs_written;
+          }
+        } catch {}
+      }
+    }
+
+    return {
+      status: 'scanned',
+      new_files: changes.new.length,
+      modified_files: changes.modified.length,
+      deleted_files: changes.deleted.length,
+      beliefs_staled: beliefsStaled,
+      beliefs_recompiled: beliefsRecompiled,
+      total_tracked: Object.keys(currentFiles).length,
+      engine: 'javascript',
+    };
+  }
+
+  start(intervalS = 120, maxFiles = 100, forceInitial = false) {
+    if (this._running) return { status: 'already_running', engine: 'javascript' };
+    this._running = true;
+
+    // Initial scan
+    const initial = this.scanOnce(forceInitial, maxFiles);
+
+    // Set up interval
+    this._interval = setInterval(() => {
+      try { this.scanOnce(false, maxFiles); } catch {}
+    }, intervalS * 1000);
+
+    // Unref so it doesn't keep the process alive
+    if (this._interval.unref) this._interval.unref();
+
+    return {
+      status: 'started',
+      interval_s: intervalS,
+      initial_scan: initial,
+      engine: 'javascript',
+    };
+  }
+
+  stop() {
+    if (this._interval) { clearInterval(this._interval); this._interval = null; }
+    this._running = false;
+    return { status: 'stopped', engine: 'javascript' };
+  }
+}
+
+module.exports = { WorkspaceChangeListener };

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "entroly-wasm",
+  "version": "0.9.0",
+  "description": "Information-theoretic context optimization for AI coding agents. Zero-friction, pure WebAssembly — no Python dependency.",
+  "main": "index.js",
+  "types": "pkg/entroly_wasm.d.ts",
+  "bin": {
+    "entroly-wasm": "./js/cli.js"
+  },
+  "files": [
+    "index.js",
+    "pkg/entroly_wasm_bg.wasm",
+    "pkg/entroly_wasm.js",
+    "pkg/entroly_wasm.d.ts",
+    "js/cli.js",
+    "js/server.js",
+    "js/config.js",
+    "js/auto_index.js",
+    "js/checkpoint.js",
+    "js/autotune.js",
+    "js/vault.js",
+    "js/cogops.js",
+    "js/workspace.js",
+    "js/repo_map.js",
+    "js/skills.js",
+    "js/multimodal.js",
+    "js/value_tracker.js",
+    "js/agentskills_export.js",
+    "js/gateways.js",
+    "js/vault_observer.js",
+    "js/distill.js",
+    "js/federation.js",
+    "js/evolution_daemon.js"
+  ],
+  "scripts": {
+    "serve": "node js/server.js",
+    "optimize": "node js/cli.js optimize",
+    "health": "node js/cli.js health",
+    "demo": "node js/cli.js demo",
+    "autotune": "node js/cli.js autotune",
+    "test": "node test_wasm_e2e.js"
+  },
+  "keywords": [
+    "entroly", "context-optimization", "mcp", "mcp-server", "ai", "agents",
+    "wasm", "webassembly", "information-theory", "knapsack", "entropy", "autotune"
+  ],
+  "repository": { "type": "git", "url": "https://github.com/juyterman1000/entroly" },
+  "author": "entroly",
+  "license": "Apache-2.0",
+  "engines": { "node": ">=16.0.0" }
+}

package/pkg/entroly_wasm.d.ts

@@ -0,0 +1,156 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class WasmEntrolyEngine {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Advance the turn counter and apply Ebbinghaus decay.
+     */
+    advance_turn(): void;
+    /**
+     * Analyze codebase health (A-F grade).
+     */
+    analyze_health(): any;
+    /**
+     * Clear EGSC cache.
+     */
+    cache_clear(): void;
+    /**
+     * Cache hit rate.
+     */
+    cache_hit_rate(): number;
+    /**
+     * Cache empty check.
+     */
+    cache_is_empty(): boolean;
+    /**
+     * Cache entry count.
+     */
+    cache_len(): number;
+    /**
+     * Classify a task query.
+     */
+    classify_task(query: string): any;
+    /**
+     * Clear all fragments and reset engine.
+     */
+    clear(): void;
+    /**
+     * Dependency graph stats.
+     */
+    dep_graph_stats(): any;
+    /**
+     * Detect entropy anomalies.
+     */
+    entropy_anomalies(): any;
+    /**
+     * Explain why each fragment was selected/excluded in last optimization.
+     */
+    explain_selection(): any;
+    /**
+     * Export all fragments as JSON.
+     */
+    export_fragments(): any;
+    /**
+     * Export full engine state as JSON string.
+     */
+    export_state(): any;
+    /**
+     * Get fragment count.
+     */
+    fragment_count(): number;
+    /**
+     * Get the current turn number.
+     */
+    get_turn(): number;
+    /**
+     * Hierarchical context compression.
+     */
+    hierarchical_compress(token_budget: number, query: string): any;
+    /**
+     * Import engine state from JSON string.
+     */
+    import_state(json_str: string): any;
+    /**
+     * Ingest a context fragment into the engine.
+     * Pipeline: tokens → SimHash → dedup → entropy → criticality → depgraph → store
+     */
+    ingest(content: string, source: string, token_count: number, is_pinned: boolean): any;
+    /**
+     * Create a new Entroly engine with default parameters.
+     */
+    constructor();
+    /**
+     * Full optimization pipeline: IOS + PRISM + Channel Coding + Resonance + Causal.
+     */
+    optimize(token_budget: number, query: string): any;
+    /**
+     * Query manifold stats.
+     */
+    query_manifold_stats(): any;
+    /**
+     * Semantic recall of relevant fragments.
+     */
+    recall(query: string, top_k: number): any;
+    /**
+     * Record failed outcome for specific fragment IDs.
+     */
+    record_failure(fragment_ids_json: string): void;
+    /**
+     * Record a continuous reward signal.
+     */
+    record_reward(fragment_ids_json: string, reward: number): void;
+    /**
+     * Record successful outcome for specific fragment IDs.
+     */
+    record_success(fragment_ids_json: string): void;
+    /**
+     * Remove a fragment by ID.
+     */
+    remove(fragment_id: string): boolean;
+    /**
+     * Scan a fragment for security vulnerabilities.
+     */
+    scan_fragment(fragment_id: string): any;
+    /**
+     * Score context utilization from LLM response.
+     */
+    score_utilization(response: string): any;
+    /**
+     * Security report for all fragments.
+     */
+    security_report(): any;
+    /**
+     * Semantic dedup report.
+     */
+    semantic_dedup_report(): any;
+    /**
+     * Set cost-per-token directly.
+     */
+    set_cache_cost_per_token(cost: number): void;
+    /**
+     * Enable/disable channel coding.
+     */
+    set_channel_coding_enabled(enabled: boolean): void;
+    /**
+     * Set exploration rate.
+     */
+    set_exploration_rate(rate: number): void;
+    /**
+     * Set cost model from model name.
+     */
+    set_model(model_name: string): void;
+    /**
+     * Enable/disable query personas.
+     */
+    set_query_personas_enabled(enabled: boolean): void;
+    /**
+     * Set scoring weights (normalized to sum=1.0).
+     */
+    set_weights(w_recency: number, w_frequency: number, w_semantic: number, w_entropy: number): void;
+    /**
+     * Get full engine statistics as JSON.
+     */
+    stats(): any;
+}