dashclaw 2.0.2 → 2.1.0

package/index.cjs

@@ -1,9 +1,16 @@
 /**
- * DashClaw SDK: CommonJS compatibility wrapper.
- * For ESM: import { DashClaw } from 'dashclaw'
- * For CJS: const { DashClaw } = require('dashclaw')
+ * DashClaw SDK v2 (Stable Runtime API)
+ * CommonJS compatibility bridge.
+ * 
+ * ESM: import { DashClaw } from 'dashclaw'
+ * CJS: const { DashClaw } = require('dashclaw')
  */
 
+const fs = require('fs');
+const path = require('path');
+
+// Minimal CommonJS shim for the v2 SDK
+// We use a simplified bridge that forwards calls to the async ESM import
 let _module;
 
 async function loadModule() {
@@ -13,79 +20,51 @@ async function loadModule() {
   return _module;
 }
 
-// Re-export via dynamic import (CJS → ESM bridge)
-module.exports = new Proxy({}, {
-  get(target, prop) {
-    if (prop === '__esModule') return true;
-    if (prop === 'then') return undefined; // Prevent Promise-like behavior
+module.exports = {
+  // Sync wrapper that returns a proxy for the DashClaw class
+  DashClaw: class DashClawProxy {
+    constructor(opts) {
+      this._opts = opts;
+      this._ready = loadModule().then(m => {
+        this._instance = new m.DashClaw(opts);
+      });
 
-    // Return a lazy-loading constructor wrapper
-    if (prop === 'GuardBlockedError') {
-      const Placeholder = class GuardBlockedError extends Error {
-        constructor(decision) {
-          const reasons = (decision.reasons || []).join('; ') || 'no reason';
-          super(`Guard blocked action: ${decision.decision}. Reasons: ${reasons}`);
-          this.name = 'GuardBlockedError';
-          this.decision = decision.decision;
-          this.reasons = decision.reasons || [];
-          this.warnings = decision.warnings || [];
-          this.matchedPolicies = decision.matched_policies || [];
-          this.riskScore = decision.risk_score ?? null;
-        }
-      };
-      
-      // Support instanceof across ESM/CJS boundary
-      loadModule().then(m => {
-        if (m.GuardBlockedError) {
-          Object.defineProperty(Placeholder, Symbol.hasInstance, {
-            value: (instance) => instance && (instance.name === 'GuardBlockedError' || instance instanceof m.GuardBlockedError)
-          });
+      return new Proxy(this, {
+        get(target, prop) {
+          if (prop in target) return target[prop];
+          if (prop === 'then') return undefined;
+
+          return async (...args) => {
+            await target._ready;
+            if (!target._instance[prop]) {
+              throw new Error(`Method ${String(prop)} does not exist on DashClaw v2`);
+            }
+            return target._instance[prop](...args);
+          };
         }
       });
-      
-      return Placeholder;
     }
-    if (prop === 'DashClaw' || prop === 'OpenClawAgent' || prop === 'default') {
-      return class DashClawProxy {
-        constructor(opts) {
-          this._opts = opts;
-          this._ready = loadModule().then(m => {
-            const Cls = m.DashClaw || m.default;
-            this._instance = new Cls(opts);
-          });
 
-          // Return a proxy that forwards all method calls to the async instance
-          return new Proxy(this, {
-            get(target, prop) {
-              if (prop in target) return target[prop];
-              if (prop === 'then') return undefined;
+    static async create(opts) {
+      const mod = await loadModule();
+      return new mod.DashClaw(opts);
+    }
+  },
 
-              return async (...args) => {
-                await target._ready;
-                if (!target._instance[prop]) {
-                  throw new Error(`Method ${String(prop)} does not exist on DashClaw`);
-                }
-                return target._instance[prop](...args);
-              };
-            }
-          });
-        }
+  // Errors from v2
+  ApprovalDeniedError: class ApprovalDeniedError extends Error {
+    constructor(message, decision) {
+      super(message);
+      this.name = 'ApprovalDeniedError';
+      this.decision = decision;
+    }
+  },
 
-        // For synchronous construction, use DashClaw.create()
-        static async create(opts) {
-          const mod = await loadModule();
-          const Cls = mod.DashClaw || mod.default;
-          return new Cls(opts);
-        }
-      };
+  GuardBlockedError: class GuardBlockedError extends Error {
+    constructor(decision) {
+      super(decision.reason || 'Action blocked by policy');
+      this.name = 'GuardBlockedError';
+      this.decision = decision;
     }
-    return undefined;
   }
-});
-
-// Preferred: async factory
-module.exports.create = async function create(opts) {
-  const mod = await loadModule();
-  const Cls = mod.DashClaw || mod.default;
-  return new Cls(opts);
 };