@asobacloud/nehanda 0.0.0-stage → 0.2.0

package/lib/scripts/js-safety-checker.cjs

@@ -0,0 +1,308 @@
+const fs = require('fs');
+const vm = require('vm');
+const path = require('path');
+const esprima = require('esprima');
+
+function checkJSFile(filePath, fileContent) {
+    const issues = [];
+    
+    // 1. JAVASCRIPT SYNTAX VALIDATION
+    try {
+        const scriptMatches = fileContent.match(/<script[^>]*>([\s\S]*?)<\/script>/g) || [];
+        // Only match actual JavaScript event handlers in HTML markup.
+        // Skip .js files entirely (they don't have real HTML inline handlers).
+        // For .html files, strip <script> blocks first so we don't match onclick
+        // inside JS string concatenation or template literals.
+        let inlineScripts = [];
+        if (filePath.endsWith('.html')) {
+            const htmlOnly = fileContent.replace(/<script[^>]*>[\s\S]*?<\/script>/g, '');
+            inlineScripts = htmlOnly.match(/\s(onclick|onload|onchange|onsubmit|onmouseover|onmouseout|onfocus|onblur|onkeydown|onkeyup)="[^"]*"/g) || [];
+        }
+        
+        scriptMatches.forEach((scriptBlock, index) => {
+            const scriptContent = scriptBlock.replace(/<\/?script[^>]*>/g, '');
+            if (scriptContent.trim()) {
+                try {
+                    vm.createScript(scriptContent, `script-block-${index}`);
+                } catch (error) {
+                    const lineNumber = getLineNumber(fileContent, scriptBlock);
+                    issues.push(`JavaScript syntax error in script block ${index + 1} at line ${lineNumber}: ${error.message}`);
+                }
+            }
+        });
+        
+        inlineScripts.forEach((inlineScript, index) => {
+            const jsCodeMatch = inlineScript.match(/="([^"]*)"/);
+            if (jsCodeMatch && jsCodeMatch[1]) {
+                const jsCode = jsCodeMatch[1];
+                if (jsCode.trim()) {
+                    try {
+                        // Wrap in function context to allow return statements
+                        vm.createScript(`(function(){${jsCode}})`, `inline-script-${index}`);
+                    } catch (error) {
+                        const lineNumber = getLineNumber(fileContent, inlineScript);
+                        issues.push(`JavaScript syntax error in inline script at line ${lineNumber}: ${error.message}`);
+                    }
+                }
+            }
+        });
+        
+    } catch (error) {
+        issues.push(`JavaScript parsing failed: ${error.message}`);
+    }
+    
+    // 2. DUPLICATE DEFINITIONS - Use AST-based detection for accuracy
+    const scriptBlocks = fileContent.match(/<script[^>]*>([\s\S]*?)<\/script>/g) || [];
+    const allFunctionNames = [];
+    
+    scriptBlocks.forEach(scriptBlock => {
+        const scriptContent = scriptBlock.replace(/<\/?script[^>]*>/g, '');
+        try {
+            const ast = esprima.parseScript(scriptContent, { tolerant: true });
+            function findFunctions(node) {
+                if (!node) return;
+                if (node.type === 'FunctionDeclaration' && node.id) {
+                    allFunctionNames.push(node.id.name);
+                }
+                for (const key in node) {
+                    if (node.hasOwnProperty(key) && typeof node[key] === 'object' && node[key] !== null) {
+                        if (Array.isArray(node[key])) {
+                            node[key].forEach(findFunctions);
+                        } else {
+                            findFunctions(node[key]);
+                        }
+                    }
+                }
+            }
+            findFunctions(ast);
+        } catch (e) {
+            // If AST parsing fails, fall back to regex but be more careful
+            const functionDefinitions = scriptContent.match(/^\s*function\s+(\w+)/gm) || [];
+            functionDefinitions.forEach(f => {
+                const match = f.match(/function\s+(\w+)/);
+                if (match) allFunctionNames.push(match[1]);
+            });
+        }
+    });
+    
+    const duplicateFunctions = allFunctionNames.filter((func, index) => allFunctionNames.indexOf(func) !== index);
+    if (duplicateFunctions.length > 0) {
+        issues.push(`Duplicate function definitions: ${duplicateFunctions.join(', ')}`);
+    }
+
+    // Only check for duplicate IDs in static HTML, ignore dynamic IDs with concatenation
+    // Match id="..." but exclude patterns with string concatenation (+ or ${})
+    const idMatches = fileContent.match(/id="([^"]+)"/g) || [];
+    const ids = idMatches
+        .map(match => match.match(/id="([^"]+)"/)[1])
+        .filter(id => !id.includes("' +") && !id.includes("+ '") && !id.includes('${') && !id.includes('}'));
+    const duplicateIds = ids.filter((id, index) => ids.indexOf(id) !== index);
+    if (duplicateIds.length > 0) {
+        issues.push(`Duplicate IDs: ${duplicateIds.join(', ')}`);
+    }
+
+    return issues;
+}
+
+function getLineNumber(content, searchString) {
+    const index = content.indexOf(searchString);
+    return index !== -1 ? content.substring(0, index).split('\n').length : 0;
+}
+
+function findFiles(dir, ext, callback) {
+    fs.readdir(dir, (err, files) => {
+        if (err) return callback(err);
+
+        files.forEach(file => {
+            const filePath = path.join(dir, file);
+            fs.stat(filePath, (err, stat) => {
+                if (err) return callback(err);
+
+                if (stat.isDirectory()) {
+                    findFiles(filePath, ext, callback);
+                } else if (path.extname(filePath) === ext) {
+                    callback(null, filePath);
+                }
+            });
+        });
+    });
+}
+
+function analyzeJS(jsContent) {
+    const declaredFunctions = new Set();
+    const declaredClasses = new Set();
+    const calledFunctions = new Set();
+
+    try {
+        const ast = esprima.parseScript(jsContent, { tolerant: true });
+
+        function traverse(node) {
+            if (!node) return;
+
+            // Track function declarations
+            if (node.type === 'FunctionDeclaration' && node.id) {
+                declaredFunctions.add(node.id.name);
+            }
+
+            // Track arrow function and function expression assignments:
+            // const/let/var name = () => {} or const/let/var name = function() {}
+            if (node.type === 'VariableDeclaration') {
+                node.declarations.forEach(declarator => {
+                    if (declarator.id && declarator.id.type === 'Identifier' && declarator.init &&
+                        (declarator.init.type === 'ArrowFunctionExpression' ||
+                         declarator.init.type === 'FunctionExpression')) {
+                        declaredFunctions.add(declarator.id.name);
+                    }
+                });
+            }
+
+            // Track class declarations
+            if (node.type === 'ClassDeclaration' && node.id) {
+                declaredClasses.add(node.id.name);
+            }
+
+            // Track function calls (e.g., myFunction())
+            if (node.type === 'CallExpression' && node.callee.type === 'Identifier') {
+                calledFunctions.add(node.callee.name);
+            }
+
+            // Track constructor calls (e.g., new MyClass())
+            if (node.type === 'NewExpression' && node.callee.type === 'Identifier') {
+                calledFunctions.add(node.callee.name);
+            }
+
+            for (const key in node) {
+                if (node.hasOwnProperty(key)) {
+                    const child = node[key];
+                    if (typeof child === 'object' && child !== null) {
+                        if (Array.isArray(child)) {
+                            child.forEach(traverse);
+                        } else {
+                            traverse(child);
+                        }
+                    }
+                }
+            }
+        }
+
+        traverse(ast);
+    } catch (e) {
+        // Ignore parsing errors, they are handled by the vm module
+    }
+
+    // Combine declared functions and classes for checking
+    const allDeclared = new Set([...declaredFunctions, ...declaredClasses]);
+    return { declaredFunctions: allDeclared, calledFunctions };
+}
+
+function main() {
+    const uiDir = process.argv[2] ? path.resolve(process.argv[2]) : __dirname;
+    let allIssues = [];
+    let filesToProcess = [];
+    const extensions = ['.html', '.js'];
+    
+    // Files and directories to exclude from safety checking
+    const excludePatterns = [
+        'js-safety-checker.js',  // Don't scan the safety checker itself
+        'node_modules',          // Exclude dependencies
+        'dist',                  // Exclude build outputs
+        'build',                 // Exclude build outputs
+        '.git',                  // Exclude git directory
+        'tests'                  // Exclude test files (Jest globals are not defined in production)
+    ];
+
+    const fileFinder = (dir, ext) => {
+        if (!fs.existsSync(dir)) return;
+        const stat = fs.statSync(dir);
+        if (stat.isFile()) {
+            if (path.extname(dir) === ext) {
+                filesToProcess.push(dir);
+            }
+            return;
+        }
+
+        const files = fs.readdirSync(dir);
+        files.forEach(file => {
+            const filePath = path.join(dir, file);
+            
+            // Skip excluded files and directories
+            const shouldExclude = excludePatterns.some(pattern => 
+                file.includes(pattern) || filePath.includes(pattern)
+            );
+            if (shouldExclude) {
+                return;
+            }
+            
+            const fileStat = fs.statSync(filePath);
+            if (fileStat.isDirectory()) {
+                fileFinder(filePath, ext);
+            } else if (path.extname(filePath) === ext) {
+                filesToProcess.push(filePath);
+            }
+        });
+    };
+
+    extensions.forEach(ext => fileFinder(uiDir, ext));
+
+    const allDeclaredFunctions = new Set();
+    const allCalledFunctions = new Set();
+
+    filesToProcess.forEach(filePath => {
+        const fileContent = fs.readFileSync(filePath, 'utf8');
+        const issues = checkJSFile(filePath, fileContent);
+        if (issues.length > 0) {
+            allIssues.push({ filePath, issues });
+        }
+
+        const { declaredFunctions, calledFunctions } = analyzeJS(fileContent);
+        declaredFunctions.forEach(f => allDeclaredFunctions.add(f));
+        calledFunctions.forEach(f => allCalledFunctions.add(f));
+    });
+
+    // Browser and Node.js global functions that should not be flagged as undefined
+    const knownGlobals = new Set([
+        'fetch', 'alert', 'confirm', 'prompt', 'console', 'setTimeout', 'setInterval',
+        'clearTimeout', 'clearInterval', 'document', 'window', 'location', 'localStorage',
+        'sessionStorage', 'JSON', 'parseInt', 'parseFloat', 'isNaN', 'isFinite', 'encodeURIComponent',
+        'decodeURIComponent', 'encodeURI', 'decodeURI', 'escape', 'unescape', 'Date', 'Math',
+        'Array', 'Object', 'String', 'Number', 'Boolean', 'RegExp', 'Error', 'require',
+        'requestAnimationFrame', 'cancelAnimationFrame', 'requestIdleCallback', 'cancelIdleCallback',
+        'Promise', 'Map', 'Set', 'WeakMap', 'WeakSet', 'Symbol', 'Proxy', 'Reflect',
+        'CustomEvent', 'Event', 'EventTarget', 'AbortController', 'AbortSignal',
+        'FormData', 'URLSearchParams', 'URL', 'Blob', 'File', 'FileReader',
+        'XMLHttpRequest', 'WebSocket', 'MutationObserver', 'IntersectionObserver',
+        'ResizeObserver', 'PerformanceObserver', 'atob', 'btoa',
+        'EventSource', 'TextDecoder', 'TextEncoder'
+    ]);
+
+    // Common callback parameter names that should not be flagged as undefined
+    const commonCallbackNames = new Set([
+        'callback', 'cb', 'done', 'next', 'fn', 'handler', 'onSuccess', 'onError',
+        'onConfirm', 'onCancel', 'resolve', 'reject', 'complete', 'unsubscribe',
+        'listener', 'subscriber', 'observer',
+        'onComplete', 'onProgress', 'onChunk', 'onDone'
+    ]);
+
+    const undefinedFunctions = [...allCalledFunctions].filter(f =>
+        !allDeclaredFunctions.has(f) && !knownGlobals.has(f) && !commonCallbackNames.has(f)
+    );
+
+    if (undefinedFunctions.length > 0) {
+        allIssues.push({ filePath: 'Global', issues: [`Undefined function calls: ${undefinedFunctions.join(', ')}`] });
+    }
+
+    if (allIssues.length > 0) {
+        console.error('JavaScript Safety Check Failed:');
+        allIssues.forEach(fileIssues => {
+            console.error(`\n❌ ${fileIssues.filePath}`);
+            fileIssues.issues.forEach(issue => {
+                console.error(`  - ${issue}`);
+            });
+        });
+        process.exit(1);
+    } else {
+        console.log(`✅ All ${filesToProcess.length} files checked: No issues found`);
+    }
+}
+
+main();

package/lib/scripts/laya_worker.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+"""JSON-lines stdio worker for Laya System-1 decisions.
+
+Loads the real convaiinnovations/laya checkpoint on `load` / first predict.
+Never silently invents answers — if Laya cannot load, every request returns ok:false.
+
+Protocol (one JSON object per line):
+  {"id":1,"method":"ping"}
+  {"id":2,"method":"load"}           # download + load checkpoint into memory
+  {"id":3,"method":"predict","params":{"state":"...","questions":{...}}}
+  {"id":4,"method":"shutdown"}
+"""
+from __future__ import annotations
+
+import json
+import sys
+import traceback
+import time
+
+_router = None
+_agent = None
+_loaded = False
+_load_error = None
+
+
+def _ensure_loaded():
+    global _router, _agent, _loaded, _load_error
+    if _loaded:
+        return
+    if _load_error is not None:
+        raise RuntimeError(_load_error)
+    t0 = time.time()
+    try:
+        from laya import Router
+        _router = Router()
+        # Force English checkpoint into memory so warm predict hits ≤50ms path.
+        # Router downloads on first predict; prime with a tiny call.
+        _router.predict(
+            "nehanda system-1 warm start",
+            {
+                "ready": {
+                    "type": "noul",
+                    "instructions": "Is the control plane ready?",
+                }
+            },
+            model="english",
+        )
+        _loaded = True
+        ms = int((time.time() - t0) * 1000)
+        print(f"[laya-worker] loaded english checkpoint in {ms}ms", file=sys.stderr)
+    except TypeError:
+        # Older Router.predict may not accept model= kwarg
+        try:
+            from laya import Router
+            _router = Router()
+            _router.predict(
+                "nehanda system-1 warm start",
+                {"ready": {"type": "noul", "instructions": "Is the control plane ready?"}},
+            )
+            _loaded = True
+            ms = int((time.time() - t0) * 1000)
+            print(f"[laya-worker] loaded via Router in {ms}ms", file=sys.stderr)
+        except Exception:
+            try:
+                import laya
+                _agent = laya.load("convaiinnovations/laya")
+                _agent.predict(
+                    "nehanda system-1 warm start",
+                    {"ready": {"type": "noul", "instructions": "Is the control plane ready?"}},
+                )
+                _loaded = True
+                ms = int((time.time() - t0) * 1000)
+                print(f"[laya-worker] loaded laya.load() in {ms}ms", file=sys.stderr)
+            except Exception as e2:
+                _load_error = f"laya load failed: {e2}"
+                raise RuntimeError(_load_error) from e2
+    except Exception as e:
+        _load_error = f"laya load failed: {e}"
+        raise RuntimeError(_load_error) from e
+
+
+def predict(state, questions):
+    _ensure_loaded()
+    if _router is not None:
+        try:
+            return _router.predict(state, questions, model="english")
+        except TypeError:
+            return _router.predict(state, questions)
+    return _agent.predict(state, questions)
+
+
+def _to_dict(result):
+    if result is None:
+        return {}
+    if isinstance(result, dict):
+        # answers may contain nested objects
+        out = {}
+        for k, v in result.items():
+            if hasattr(v, "keys") and not isinstance(v, dict):
+                try:
+                    out[k] = dict(v)
+                    continue
+                except Exception:
+                    pass
+            if isinstance(v, dict):
+                nested = {}
+                for nk, nv in v.items():
+                    if hasattr(nv, "keys") and not isinstance(nv, dict):
+                        try:
+                            nested[nk] = dict(nv)
+                            continue
+                        except Exception:
+                            pass
+                    nested[nk] = nv
+                out[k] = nested
+            else:
+                out[k] = v
+        return out
+    if hasattr(result, "keys"):
+        return dict(result)
+    return {"raw": str(result)}
+
+
+def handle(msg):
+    method = msg.get("method")
+    mid = msg.get("id")
+    params = msg.get("params") or {}
+    if method == "ping":
+        return {"id": mid, "ok": True, "result": {"pong": True, "loaded": _loaded}}
+    if method == "load":
+        _ensure_loaded()
+        return {"id": mid, "ok": True, "result": {"loaded": True}}
+    if method == "shutdown":
+        return {"id": mid, "ok": True, "result": {"bye": True}, "_exit": True}
+    if method == "predict":
+        result = predict(params.get("state", ""), params.get("questions") or {})
+        return {"id": mid, "ok": True, "result": _to_dict(result)}
+    return {"id": mid, "ok": False, "error": f"unknown method: {method}"}
+
+
+def main():
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            msg = json.loads(line)
+        except json.JSONDecodeError as e:
+            sys.stdout.write(json.dumps({"ok": False, "error": f"bad json: {e}"}) + "\n")
+            sys.stdout.flush()
+            continue
+        try:
+            resp = handle(msg)
+            do_exit = resp.pop("_exit", False)
+            sys.stdout.write(json.dumps(resp, default=str) + "\n")
+            sys.stdout.flush()
+            if do_exit:
+                return 0
+        except Exception as e:
+            traceback.print_exc(file=sys.stderr)
+            sys.stdout.write(json.dumps({
+                "id": msg.get("id"),
+                "ok": False,
+                "error": str(e),
+            }) + "\n")
+            sys.stdout.flush()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/lib/scripts/odse-transform.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+"""
+odse-transform.py — ODSE energy normalization bridge for nehanda-cli.
+
+Reads a raw OEM energy payload from stdin, transforms it to ODS-E
+normalized JSON using the pip-installed `odse` package, and writes
+the result to stdout as a JSON array.
+
+Usage:
+    echo '<payload>' | python3 odse-transform.py --source huawei
+    echo '<payload>' | python3 odse-transform.py --source solaredge --asset-id SITE-001
+
+Exit codes:
+    0  — success, normalized JSON written to stdout
+    1  — unknown source / transform error (caller should pass payload through)
+    2  — usage / import error
+"""
+
+import argparse
+import json
+import sys
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Transform OEM energy data to ODS-E")
+    parser.add_argument(
+        "--source",
+        required=True,
+        help="OEM source key (e.g. huawei, solaredge, enphase, sungrow)",
+    )
+    parser.add_argument(
+        "--asset-id",
+        default=None,
+        dest="asset_id",
+        help="Optional asset identifier to embed in output records",
+    )
+    parser.add_argument(
+        "--timezone",
+        default=None,
+        help="Optional timezone for timestamp conversion (e.g. Africa/Johannesburg)",
+    )
+    args = parser.parse_args()
+
+    # Read full payload from stdin
+    try:
+        payload = sys.stdin.read()
+    except Exception as exc:
+        print(f"[odse-transform] stdin read error: {exc}", file=sys.stderr)
+        return 2
+
+    if not payload.strip():
+        print("[odse-transform] empty payload", file=sys.stderr)
+        return 1
+
+    # Import odse — fail fast with a clear message if not installed
+    try:
+        from odse.transformer import transform  # noqa: PLC0415
+    except ImportError:
+        print(
+            "[odse-transform] odse package not found. Run: pip install odse",
+            file=sys.stderr,
+        )
+        return 2
+
+    # Attempt transformation
+    try:
+        kwargs: dict = {}
+        if args.timezone:
+            kwargs["timezone"] = args.timezone
+
+        records = transform(
+            payload,
+            source=args.source,
+            asset_id=args.asset_id,
+            **kwargs,
+        )
+    except ValueError as exc:
+        # Unknown source key — caller interprets exit 1 as "pass through"
+        print(f"[odse-transform] unknown source '{args.source}': {exc}", file=sys.stderr)
+        return 1
+    except Exception as exc:  # noqa: BLE001
+        # Transform failed (malformed payload, etc.) — pass through
+        print(f"[odse-transform] transform error: {exc}", file=sys.stderr)
+        return 1
+
+    # Write normalized records as JSON array to stdout
+    try:
+        print(json.dumps(records, default=str))
+    except Exception as exc:
+        print(f"[odse-transform] serialization error: {exc}", file=sys.stderr)
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())