@garrix82/reactgenie-lib 1.3.0

package/metro/with-genie-registry.js

@@ -0,0 +1,47 @@
+const fs = require("fs");
+const path = require("path");
+const { generateGenieRegistry } = require("../scripts/generate-genie-registry");
+const logger = require("../utils/logger")("genie-registry");
+
+function withGenieRegistry(config, options = {}) {
+  const projectRoot = options.projectRoot || process.cwd();
+  const appDir = options.appDir || path.join(projectRoot, "app");
+  const outFile = options.outFile || path.join(appDir, "genie-registry.ts");
+  const watch =
+    options.watch !== undefined ? options.watch : process.env.NODE_ENV !== "production";
+
+  generateGenieRegistry({ projectRoot, appDir, outFile });
+
+  if (watch && fs.existsSync(appDir)) {
+    let timer = null;
+    const watcher = fs.watch(
+      appDir,
+      { recursive: true },
+      (eventType, filename) => {
+        if (!filename) return;
+        if (filename.endsWith("genie-registry.ts")) return;
+        if (!filename.endsWith(".ts") && !filename.endsWith(".tsx")) return;
+        if (timer) clearTimeout(timer);
+        timer = setTimeout(() => {
+          try {
+            generateGenieRegistry({ projectRoot, appDir, outFile });
+          } catch (error) {
+            logger.error(String(error));
+          }
+        }, 100);
+      }
+    );
+
+    if (watcher && watcher.on) {
+      watcher.on("error", (error) => {
+        logger.warn("[genie-registry] watcher error:", error);
+      });
+    }
+  }
+
+  return config;
+}
+
+module.exports = {
+  withGenieRegistry,
+};

package/package.json

@@ -0,0 +1,111 @@
+{
+    "name": "@garrix82/reactgenie-lib",
+    "version": "1.3.0",
+    "description": "A Toolkit for Multimodal Applications",
+    "author": "Omkar Mirgal <github.com/OmkarMirgal>",
+    "license": "Apache-2.0",
+    "keywords": ["Multimodal", "Voice-interface", "React Native", "Toolkit"],
+    "main": "dist/index.js",
+    "scripts": {
+        "test": "jest",
+        "test:babel": "babel-node -x .ts ./scripts/get-prompt.ts",
+        "test:watch": "jest --watch",
+        "test:coverage": "jest --coverage",
+        "test:web": "jest genie-view-wrapper.web.test",
+        "test:ios": "jest genie-view-wrapper.ios.test",
+        "test:android": "jest genie-view-wrapper.android.test",
+        "prepare": "if [ -d \"dist\" ]; then rm -r dist; fi && tsc --emitDeclarationOnly --skipLibCheck && pnpm babel src --out-file-extension .js --out-dir dist --extensions \".ts,.tsx\" --source-maps inline",
+        "clean": "rm -rf dist",
+        "publish:local": "pnpm publish --registry http://localhost:4873 --no-git-checks",
+        "version:patch": "pnpm version patch && pnpm run publish:local"
+    },
+    "bin": {
+        "get-prompt": "./scripts/prompt.js",
+        "dry-run": "./scripts/dry-run.js",
+        "set-script": "./scripts/set-script.js",
+        "parse": "./scripts/parse.js"
+    },
+    "devDependencies": {
+        "@babel/cli": "^7.23.0",
+        "@babel/node": "^7.22.19",
+        "@babel/preset-env": "^7.28.0",
+        "@babel/preset-typescript": "^7.27.1",
+        "@testing-library/jest-dom": "^6.1.5",
+        "@testing-library/react": "^14.1.2",
+        "@testing-library/react-native": "^12.4.2",
+        "@types/jest": "^29.5.11",
+        "@types/node": "^25.3.0",
+        "@types/react-speech-recognition": "^3.9.4",
+        "@typescript-eslint/eslint-plugin": "^6.10.0",
+        "@typescript-eslint/parser": "^6.10.0",
+        "babel-jest": "^29.7.0",
+        "babel-plugin-parameter-decorator": "^1.0.16",
+        "babel-plugin-reactgenie": "0.3.8",
+        "eslint": "^8.53.0",
+        "eslint-plugin-react": "^7.32.2",
+        "eslint-plugin-react-hooks": "^4.6.0",
+        "expo-yarn-workspaces": "^2.2.2",
+        "jest": "^29.7.0",
+        "jest-environment-jsdom": "^29.7.0",
+        "prettier": "3.0.3",
+        "react-test-renderer": "^19.2.0"
+    },
+    "dependencies": {
+        "@babel/core": "^7.23.3",
+        "@babel/plugin-proposal-decorators": "^7.23.3",
+        "@babel/preset-react": "^7.23.3",
+        "@expo/vector-icons": "^13.0.0 || ^14.0.0 || ^15.0.0",
+        "@garrix82/reactgenie-dsl": "1.0.0",
+        "@react-native-material/core": "^1.3.7",
+        "@react-navigation/stack": "^7.0.0",
+        "@reduxjs/toolkit": "^2.8.2",
+        "expo-blur": "~15.0.8",
+        "microsoft-cognitiveservices-speech-sdk": "1.32.0",
+        "p-defer-es5": "^2.0.1",
+        "react-native-elements": "^3.4.3",
+        "react-native-logs": "^5.1.0",
+        "react-native-root-toast": "^3.5.1",
+        "react-speech-recognition": "^3.9.1",
+        "reflect-metadata": "^0.1.13",
+        "regenerator-runtime": "^0.14.0",
+        "sonner-native": "^0.21.1",
+        "web-speech-cognitive-services": "7.1.3"
+    },
+    "optionalDependencies": {
+        "winston": "^3.10.0"
+    },
+    "peerDependencies": {
+        "@react-navigation/native": "^6.1.9 || ^7.0.0",
+        "@react-navigation/native-stack": "^6.9.17 || ^7.0.0",
+        "expo-audio": "*",
+        "expo-file-system": "~17.0.0 || ~18.0.0",
+        "expo-router": "^6.0.0",
+        "expo-speech": "*",
+        "react": "^18.2.0 || ^19.0.0",
+        "react-dom": "^18.2.0 || ^19.0.0",
+        "react-native": "^0.72.6 || ^0.73.0 || ^0.74.0 || ^0.75.0 || ^0.76.0 || ^0.81.0",
+        "react-native-webrtc": "*",
+        "react-redux": "^8.1.3 || ^9.0.0",
+        "redux": "^4.2.1 || ^5.0.0"
+    },
+    "peerDependenciesMeta": {
+        "expo-router": {
+            "optional": true
+        },
+        "@react-navigation/native-stack": {
+            "optional": true
+        },
+        "expo-audio": {
+            "optional": true
+        },
+        "expo-file-system": {
+            "optional": true
+        },
+        "expo-speech": {
+            "optional": true
+        },
+        "react-native-webrtc": {
+            "optional": true
+        }
+    }
+}

package/scripts/dry-run.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+// const args = process.argv.slice(2);
+// console.log("Input Command:\n", args);
+
+// let fs = require("fs");
+// fs.writeFileSync("./__test__/dry-run-input.txt", args[0]);
+
+const { spawn } = require("child_process");
+let command = "npx";
+
+// Check if the operating system is Windows
+if (process.platform === "win32") {
+  command = "npx.cmd";
+}
+const childProcess = spawn(command, ["jest", "./__test__/dry-run.test.ts"]);
+childProcess.stdout.pipe(process.stdout);
+
+console.log("Running Test ... ");
+// childProcess.on("close", function(code, signal) {
+//     const result = fs.readFileSync("./__test__/dry-run-result.txt", "utf8");
+//     console.log("Result:\n", result);
+// });

package/scripts/generate-genie-registry.js

@@ -0,0 +1,278 @@
+const fs = require("fs");
+const path = require("path");
+
+const ROUTE_FILE_EXTS = new Set([".ts", ".tsx"]);
+
+const HOOK_REGEX =
+  /useRegisterGenieRoute\s*\(\s*(['"`])([^'"`]+)\1\s*(?:,\s*(['"`])([^'"`]+)\3\s*)?\)/g;
+
+function walk(dir) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "node_modules" || entry.name === ".expo") {
+        continue;
+      }
+      files.push(...walk(fullPath));
+      continue;
+    }
+    if (!ROUTE_FILE_EXTS.has(path.extname(entry.name))) {
+      continue;
+    }
+    files.push(fullPath);
+  }
+  return files;
+}
+
+function isRouteFile(appDir, filePath) {
+  const rel = path.relative(appDir, filePath);
+  const base = path.basename(filePath);
+  if (rel.startsWith("genie-registry.")) return false;
+  if (base.startsWith("_") || base.startsWith("+")) return false;
+  return true;
+}
+
+function normalizeRoutePath(appDir, filePath) {
+  const rel = path.relative(appDir, filePath);
+  const noExt = rel.replace(path.extname(rel), "");
+  const rawSegments = noExt.split(path.sep);
+  const segments = [];
+  for (const segment of rawSegments) {
+    if (!segment) continue;
+    if (segment.startsWith("(") && segment.endsWith(")")) {
+      continue;
+    }
+    if (segment === "index") {
+      continue;
+    }
+    segments.push(segment);
+  }
+  return "/" + segments.join("/");
+}
+
+function toImportPath(appDir, filePath) {
+  const rel = path.relative(appDir, filePath);
+  const noExt = rel.replace(path.extname(rel), "");
+  return "./" + noExt.split(path.sep).join("/");
+}
+
+function extractRegistrations(content) {
+  // Strip comments so commented-out hooks do not get treated as real registrations.
+  // This keeps the generated registry aligned with actual executable route code.
+  const source = stripComments(content);
+  const results = [];
+  let match;
+  while ((match = HOOK_REGEX.exec(source)) !== null) {
+    const viewClassName = match[2];
+    const explicitPath = match[4] || null;
+    results.push({ viewClassName, explicitPath });
+  }
+  return results;
+}
+
+function stripComments(input) {
+  let output = "";
+  let i = 0;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let inTemplateString = false;
+  let escaped = false;
+
+  while (i < input.length) {
+    const char = input[i];
+    const next = input[i + 1];
+
+    if (inLineComment) {
+      if (char === "\n") {
+        inLineComment = false;
+        output += char;
+      }
+      i += 1;
+      continue;
+    }
+
+    if (inBlockComment) {
+      if (char === "*" && next === "/") {
+        inBlockComment = false;
+        i += 2;
+        continue;
+      }
+      if (char === "\n") {
+        output += char;
+      }
+      i += 1;
+      continue;
+    }
+
+    if (inSingleQuote) {
+      output += char;
+      if (!escaped && char === "'") {
+        inSingleQuote = false;
+      }
+      escaped = !escaped && char === "\\";
+      i += 1;
+      continue;
+    }
+
+    if (inDoubleQuote) {
+      output += char;
+      if (!escaped && char === "\"") {
+        inDoubleQuote = false;
+      }
+      escaped = !escaped && char === "\\";
+      i += 1;
+      continue;
+    }
+
+    if (inTemplateString) {
+      output += char;
+      if (!escaped && char === "`") {
+        inTemplateString = false;
+      }
+      escaped = !escaped && char === "\\";
+      i += 1;
+      continue;
+    }
+
+    if (char === "/" && next === "/") {
+      inLineComment = true;
+      i += 2;
+      continue;
+    }
+
+    if (char === "/" && next === "*") {
+      inBlockComment = true;
+      i += 2;
+      continue;
+    }
+
+    if (char === "'") {
+      inSingleQuote = true;
+      escaped = false;
+      output += char;
+      i += 1;
+      continue;
+    }
+
+    if (char === "\"") {
+      inDoubleQuote = true;
+      escaped = false;
+      output += char;
+      i += 1;
+      continue;
+    }
+
+    if (char === "`") {
+      inTemplateString = true;
+      escaped = false;
+      output += char;
+      i += 1;
+      continue;
+    }
+
+    output += char;
+    i += 1;
+  }
+
+  return output;
+}
+
+function generateGenieRegistry(options = {}) {
+  const projectRoot = options.projectRoot || process.cwd();
+  const appDir =
+    options.appDir || process.env.GENIE_APP_DIR || path.join(projectRoot, "app");
+  const outFile =
+    options.outFile ||
+    process.env.GENIE_REGISTRY_OUT ||
+    path.join(appDir, "genie-registry.ts");
+
+  if (!fs.existsSync(appDir)) {
+    console.warn(`[genie-registry] app directory not found: ${appDir}`);
+    return { appDir, outFile, registrations: [], written: false };
+  }
+
+  const files = walk(appDir).filter((filePath) => isRouteFile(appDir, filePath));
+  const routeImports = new Set();
+  const registrations = [];
+  const seenViewClass = new Map();
+  const conflicts = [];
+
+  for (const filePath of files) {
+    const content = fs.readFileSync(filePath, "utf8");
+    const hooks = extractRegistrations(content);
+    if (hooks.length === 0) continue;
+
+    const routePath = normalizeRoutePath(appDir, filePath);
+    const importPath = toImportPath(appDir, filePath);
+    routeImports.add(importPath);
+
+    for (const hook of hooks) {
+      const viewClassName = hook.viewClassName;
+      const finalPath = hook.explicitPath || routePath || "/";
+      if (seenViewClass.has(viewClassName)) {
+        const existing = seenViewClass.get(viewClassName);
+        if (existing !== finalPath) {
+          conflicts.push(
+            `Duplicate view class "${viewClassName}" mapped to "${existing}" and "${finalPath}"`
+          );
+        }
+        continue;
+      }
+      seenViewClass.set(viewClassName, finalPath);
+      registrations.push({ viewClassName, routePath: finalPath });
+    }
+  }
+
+  if (conflicts.length > 0) {
+    const message = ["[genie-registry] Conflicts found:"]
+      .concat(conflicts.map((conflict) => ` - ${conflict}`))
+      .join("\n");
+    throw new Error(message);
+  }
+
+  registrations.sort((a, b) => a.viewClassName.localeCompare(b.viewClassName));
+
+  const lines = [];
+  lines.push("/*");
+  lines.push(" * Auto-generated by reactgenie.");
+  lines.push(" * Do not edit manually.");
+  lines.push(" */");
+  lines.push("");
+  lines.push('import { registerGenieRoute } from "@garrix82/reactgenie-lib";');
+  for (const importPath of Array.from(routeImports).sort()) {
+    lines.push(`import "${importPath}";`);
+  }
+  lines.push("");
+  for (const entry of registrations) {
+    lines.push(
+      `registerGenieRoute("${entry.viewClassName}", "${entry.routePath}");`
+    );
+  }
+  lines.push("");
+  lines.push("// Expo Router requires a default export for every route module.");
+  lines.push("export default function GenieRegistryRoute() {");
+  lines.push("  return null;");
+  lines.push("}");
+  lines.push("");
+
+  fs.mkdirSync(path.dirname(outFile), { recursive: true });
+  fs.writeFileSync(outFile, lines.join("\n"));
+  return { appDir, outFile, registrations, written: true };
+}
+
+if (require.main === module) {
+  const result = generateGenieRegistry();
+  if (result.written && result.outFile) {
+    console.log(
+      `[genie-registry] Wrote ${path.relative(process.cwd(), result.outFile)}`
+    );
+  }
+}
+
+module.exports = {
+  generateGenieRegistry,
+};

package/scripts/log-file-test.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+// Simple test script to verify log file creation using the same naming scheme
+const fs = require('fs');
+const path = require('path');
+
+const env = process.env;
+const logFileDir = env.REACT_APP_LOG_FILE_DIR || env.EXPO_PUBLIC_LOG_FILE_DIR || env.LOG_FILE_DIR || '.';
+const resolvedDir = path.resolve(process.cwd(), logFileDir);
+
+// Helper to build date-based file path
+function buildFilePath() {
+  const now = new Date();
+  const pad = (n) => String(n).padStart(2, '0');
+  const dateStamp = `${now.getFullYear()}-${pad(now.getMonth()+1)}-${pad(now.getDate())}`;
+  const fileName = `logs-${dateStamp}.log`;
+  return path.join(resolvedDir, fileName);
+}
+
+// Try to load the real logger from dist or src
+let usedLogger = null;
+try {
+  // prefer built dist logger
+  const distPath = path.resolve(process.cwd(), 'dist', 'logger.js');
+  if (fs.existsSync(distPath)) {
+    usedLogger = require(distPath).default || require(distPath).logger || require(distPath);
+  }
+} catch (e) { /* ignore */ }
+
+if (!usedLogger) {
+  try {
+    // try to require source logger (may fail if no ts support)
+    const srcPath = path.resolve(process.cwd(), 'src', 'logger.ts');
+    if (fs.existsSync(srcPath)) {
+      usedLogger = require(srcPath).default || require(srcPath).logger || require(srcPath);
+    }
+  } catch (e) { /* ignore */ }
+}
+
+if (usedLogger && typeof usedLogger.info === 'function') {
+  usedLogger.info('log-file-test: writing test log via logger');
+  console.log('Wrote test log via logger (check configured log outputs)');
+} else {
+  // fallback: ensure dir exists and append file directly
+  if (!fs.existsSync(resolvedDir)) {
+    try { fs.mkdirSync(resolvedDir, { recursive: true }); } catch (e) { console.error('mkdir failed', e); process.exit(1); }
+  }
+  const filePath = buildFilePath();
+  const line = `[test] ${new Date().toISOString()} test log line\n`;
+  fs.appendFileSync(filePath, line);
+  console.log('Wrote fallback test log to', filePath);
+}

package/scripts/parse.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+const args = process.argv.slice(2);
+console.log("Input Command:\n", args);
+
+// let fs = require("fs");
+// fs.writeFileSync("./__test__/dry-run-input.txt", args[0]);
+
+const { spawn } = require("child_process");
+let command = "npx";
+
+// Check if the operating system is Windows
+if (process.platform === "win32") {
+  command = "npx.cmd";
+}
+const childProcess = spawn(command, ["jest", "./__test__/parse.test.ts", args[0]]);
+console.log("Running Test ... ");
+childProcess.stdout.pipe(process.stdout);
+
+
+
+// console.log("Running Test ... ");
+// childProcess.on("close", function(code, signal) {
+//     const result = fs.readFileSync("./__test__/dry-run-result.txt", "utf8");
+//     console.log("Result:\n", result);
+// });

package/scripts/prompt.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+const { spawn } = require("child_process");
+
+let command = "npx";
+
+// Check if the operating system is Windows
+if (process.platform === "win32") {
+  command = "npx.cmd";
+}
+
+const childProcess = spawn(command, ["jest", "./__test__/prompt.test.ts"]);
+console.log("Generating Prompt ... ");
+
+let fs = require("fs");
+childProcess.on("exit", function (code, signal) {
+  const result = fs.readFileSync("./__test__/prompt.txt", "utf8");
+  console.log("Prompt:\n", result);
+});