luca 2.0.0 → 3.0.2

package/src/web/features/vm.ts

@@ -0,0 +1,85 @@
+// @ts-nocheck
+//
+import { z } from 'zod'
+import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
+import vm from '../shims/isomorphic-vm'
+import { Feature } from "../feature.js";
+
+export const VMStateSchema = FeatureStateSchema.extend({})
+
+export const VMOptionsSchema = FeatureOptionsSchema.extend({
+  context: z.any().describe('VM context object').optional(),
+})
+
+export type VMState = z.infer<typeof VMStateSchema>
+export type VMOptions = z.infer<typeof VMOptionsSchema>
+
+/**
+ * Sandboxed JavaScript execution environment for the browser.
+ *
+ * Automatically injects the container's context object into the global scope,
+ * so evaluated code can use anything provided by the container. Useful for
+ * live code playgrounds, plugin systems, and dynamic script evaluation.
+ *
+ * @extends Feature
+ *
+ * @example
+ * ```typescript
+ * const vm = container.feature('vm')
+ * const result = vm.run('1 + 2 + 3') // 6
+ * const greeting = vm.run('container.uuid') // accesses container globals
+ * ```
+ */
+export class VM<
+  T extends VMState = VMState,
+  K extends VMOptions = VMOptions
+> extends Feature<T, K> {
+
+  static override stateSchema = VMStateSchema
+  static override optionsSchema = VMOptionsSchema
+  static override shortcut = "features.vm" as const
+
+  static { Feature.register(this, 'vm') }
+
+  createScript(code: string) {
+    return new vm.Script(code)
+  }
+ 
+  createContext(ctx: any = {}) {
+    return vm.createContext({
+      ...this.container.context,
+      ...ctx
+    })
+  }
+  
+  async run(code: string, ctx: any = {}, options : any = {}) {
+    let script = this.createScript(code)
+    
+    if (options.transform) {
+      const esbuild = this.container.feature('esbuild')
+      await esbuild.start()
+      const result = await esbuild.compile(code, options.transform)
+      script = this.createScript(result.code)
+    }
+
+    const context = this.createContext(ctx)
+    
+    try {
+      const result = script.runInContext({
+        ...context,
+        ...(options.exports && { exports: options.exports })
+      })
+  
+      if (options.exports) {
+        return { result, exports: options.exports, context }
+      }
+      
+      return result
+    } catch(error) {
+      console.error(`Error running code`, error)
+      return error
+    }
+  }
+}
+
+export default VM;

package/src/web/features/voice-recognition.ts

@@ -0,0 +1,161 @@
+import { z } from 'zod'
+import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
+import { Feature } from "../../feature.js";
+import { type ContainerContext } from '../container.js'
+
+export const VoiceRecognitionOptionsSchema = FeatureOptionsSchema.extend({
+  language: z.string().optional().describe('BCP 47 language code for recognition (e.g. en-US)'),
+  continuous: z.boolean().optional().describe('Whether to continuously listen for speech'),
+  autoListen: z.boolean().optional().describe('Whether to automatically start listening on creation'),
+})
+
+export const VoiceRecognitionStateSchema = FeatureStateSchema.extend({
+  listening: z.boolean().describe('Whether the recognizer is currently listening'),
+  transcript: z.string().describe('Accumulated final transcript text'),
+})
+
+export type VoiceRecognitionOptions = z.infer<typeof VoiceRecognitionOptionsSchema>
+export type VoiceRecognitionState = z.infer<typeof VoiceRecognitionStateSchema>
+
+export const VoiceRecognitionEventsSchema = FeatureEventsSchema.extend({
+  result: z.tuple([
+    z.object({
+      finalTranscript: z.string().describe('Accumulated final transcript text'),
+      interimTranscript: z.string().describe('Current interim transcript text'),
+    }).describe('Recognition result payload'),
+  ]).describe('Fires when speech recognition produces a result'),
+  error: z.tuple([z.string().describe('Error message from the recognizer')]).describe('Fires when speech recognition encounters an error'),
+  end: z.tuple([]).describe('Fires when speech recognition ends'),
+  start: z.tuple([]).describe('Fires when speech recognition starts listening'),
+  stop: z.tuple([]).describe('Fires when speech recognition is manually stopped'),
+  abort: z.tuple([]).describe('Fires when speech recognition is aborted'),
+}).describe('VoiceRecognition events')
+
+/**
+ * Speech-to-text recognition using the Web Speech API (SpeechRecognition).
+ *
+ * Wraps the browser's built-in speech recognition, supporting continuous
+ * listening, interim results, and language selection. Recognized text is
+ * accumulated in state and emitted as events for real-time transcription UIs.
+ *
+ * @extends Feature
+ *
+ * @example
+ * ```typescript
+ * const voice = container.feature('voice', { continuous: true, autoListen: true })
+ *
+ * voice.on('transcript', ({ text }) => {
+ *   console.log('Heard:', text)
+ * })
+ *
+ * // Or start manually
+ * voice.start()
+ * ```
+ */
+export class VoiceRecognition<T extends VoiceRecognitionState = VoiceRecognitionState, K extends VoiceRecognitionOptions = VoiceRecognitionOptions> extends Feature<T, K> {
+  // @ts-ignore-next-line
+  private recognition: SpeechRecognition | null = null;
+
+  static override stateSchema = VoiceRecognitionStateSchema
+  static override optionsSchema = VoiceRecognitionOptionsSchema
+  static override eventsSchema = VoiceRecognitionEventsSchema
+  static override shortcut = "features.voice" as const
+
+  static { Feature.register(this as any, 'voice') }
+
+  constructor(options: K, context: ContainerContext) {
+    super(options, context);
+
+    this.state.set("listening", false);
+    this.state.set("transcript", "");
+
+    if (!('webkitSpeechRecognition' in window)) {
+      throw new Error('Voice recognition is not supported in this browser.');
+    }
+
+    // @ts-ignore-next-line
+    this.recognition = new webkitSpeechRecognition();
+    this.recognition.lang = this.options.language || "en-US";
+    this.recognition.continuous = this.options.continuous || false;
+    this.recognition.interimResults = true;
+
+    this.recognition.onresult = (event: any) => {
+      let interimTranscript = "";
+      for (let i = event.resultIndex; i < event.results.length; i++) {
+        const transcript = event.results[i][0].transcript;
+        if (event.results[i].isFinal) {
+          this.state.set("transcript", this.state.get("transcript") + transcript);
+        } else {
+          interimTranscript += transcript;
+        }
+      }
+      this.emit("result", {
+        finalTranscript: this.state.get("transcript"),
+        interimTranscript
+      });
+    };
+
+    this.recognition.onerror = (event: any) => {
+      this.emit("error", event.error);
+    };
+
+    this.recognition.onend = () => {
+      this.state.set("listening", false);
+      this.emit("end");
+    };
+    
+    if (options?.autoListen) {
+      this.start()
+    }
+  }
+
+  /** Whether the speech recognizer is currently listening for audio input. */
+  get listening() {
+    return !!this.state.get("listening");
+  }
+
+  /** Returns the accumulated final transcript text from recognition results. */
+  get transcript() {
+    return this.state.get("transcript") || '';
+  }
+  
+  async whenFinished() {
+    if(!this.listening) {
+      this.start()
+    }
+
+    return await this.waitFor("end").then(() => this.transcript)  
+  }
+
+  start() {
+    this.state.set('transcript', '')
+
+    if (!this.listening && this.recognition) {
+      this.recognition.start();
+      this.state.set("listening", true);
+      this.emit("start");
+    }
+  }
+
+  stop() {
+    if (this.listening && this.recognition) {
+      this.recognition.stop();
+      this.state.set("listening", false);
+      this.emit("stop");
+    }
+  }
+
+  abort() {
+    if (this.listening && this.recognition) {
+      this.recognition.abort();
+      this.state.set("listening", false);
+      this.emit("abort");
+    }
+  }
+
+  clearTranscript() {
+    this.state.set("transcript", "");
+  }
+}
+
+export default VoiceRecognition;

package/src/web/shims/isomorphic-vm.ts

@@ -0,0 +1,149 @@
+const globals = ['Array', 'Boolean', 'Date', 'Error', 'EvalError', 'Function',
+  'Infinity', 'JSON', 'Math', 'NaN', 'Number', 'Object', 'RangeError',
+  'ReferenceError', 'RegExp', 'String', 'SyntaxError', 'TypeError', 'URIError',
+  'decodeURI', 'decodeURIComponent', 'encodeURI', 'encodeURIComponent', 'escape',
+  'eval', 'isFinite', 'isNaN', 'parseFloat', 'parseInt', 'undefined', 'unescape'];
+
+class Context { 
+  [key: string]: any;
+}
+
+function createContext(context?: any): Context {
+  var copy = new Context();
+
+  if (typeof context === 'object') {
+    Object.keys(context).forEach(key => copy[key] = context[key]);
+  }
+
+  return copy;
+};
+
+function isContext(context: any): context is Context {
+  return context instanceof Context;
+}
+
+function runInContext(code: string, context: Context): any {
+  const iframe = document.createElement('iframe');
+
+  if (!iframe.style) {
+    (iframe as any).style = {};
+  }
+
+  iframe.style.display = 'none';
+
+  document.body.appendChild(iframe);
+
+  const iframeWindow: any = iframe.contentWindow;
+  let iframeEval = iframeWindow.eval;
+
+  if (!iframeEval && iframeWindow.execScript) {
+    iframeWindow.execScript.call(iframeWindow, 'null');
+    iframeEval = iframeWindow.eval;
+  }
+
+  Object.keys(context).forEach(key => {
+    iframeWindow[key] = context[key];
+  });
+
+  Object.keys(globals).forEach(key => {
+    if (context[key]) {
+      iframeWindow[key] = context[key];
+    }
+  });
+
+  const result = iframeEval.call(iframeWindow, code);
+
+  Object.keys(iframeWindow).forEach(key => {
+    if (key in context || Object.keys(iframeWindow).indexOf(key) === -1) {
+      context[key] = iframeWindow[key];
+    }
+  });
+
+  globals.forEach(key => {
+    if (!(key in context)) {
+      Object.defineProperty(context, key, {
+        writable: true,
+        enumerable: false,
+        configurable: true,
+        value: iframeWindow[key],
+      });
+    }
+  });
+
+  document.body.removeChild(iframe);
+
+  return result;
+};
+
+function runInDebugContext(code: string): any {
+  return runInNewContext(code);
+};
+
+function runInNewContext(code: string, context?: any): any {
+  const contextInstance = createContext(context);
+  const result = runInContext(code, contextInstance);
+
+  if (typeof context === 'object') {
+    Object.keys(contextInstance).forEach(key => {
+      context[key] = contextInstance[key];
+    });
+  }
+
+  return result;
+};
+
+function runInThisContext(code: string): any {
+  return (0, eval)(code);
+};
+
+class Script {
+  private code: string;
+  constructor(code: string) {
+    this.code = code;
+  }
+
+  runInContext(context: Context) {
+    return runInContext(this.code, context);
+  }
+
+  runInNewContext(context?: any) {
+    return runInNewContext(this.code, context);
+  }
+
+  runInThisContext() {
+    return runInThisContext(this.code);
+  }
+}
+
+export interface VMContext {
+  [name: string]: any;
+}
+
+export interface VMScript {
+  new (code: string) : VMScript;
+  runInContext(context: VMContext) : any;
+  runInNewContext(context?: any) : any;
+  runInThisContext() : any;
+}
+
+export interface VM {
+  Script: VMScript;
+  createContext(context?: any): VMContext;
+  isContext(context: any): context is VMContext;
+  runInContext(code: string, context: VMContext): any;
+  runInDebugContext(code: string): any;
+  runInNewContext(code: string, context?: any): any;
+  runInThisContext(code: string): any;
+}
+
+export const shim: VM = <any>{
+  Script,
+  createContext,
+  isContext,
+  runInContext,
+  runInDebugContext,
+  runInNewContext,
+  runInThisContext,
+};
+
+export default shim as VM 

package/tsconfig.build.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "emitDeclarationOnly": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx"]
+}

package/tsconfig.json

@@ -0,0 +1,58 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext", "dom", "dom.iterable"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Path mapping for absolute imports
+    "baseUrl": ".",
+    "paths": {
+      "@/experts/*": ["identities/*"],
+      "@/*": ["src/*"],
+      "@/web/*": ["src/web/*"],
+      "@/node/*": ["src/node/*"],
+      "luca": ["src/node.ts"],
+      "luca/node": ["src/node.ts"],
+      "luca/node/*": ["src/node/*"],
+      "luca/agi": ["src/agi/index.ts"],
+      "luca/agi/*": ["src/agi/*"],
+      "luca/web": ["src/browser.ts"],
+      "luca/web/*": ["src/web/*"],
+      "luca/schemas": ["src/schemas/base.ts"],
+      "luca/schemas/*": ["src/schemas/*"],
+      "luca/container": ["src/container.ts"],
+      "luca/client": ["src/client.ts"],
+      "luca/feature": ["src/feature.ts"]
+    },
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  },
+  "include": ["*.ts", "src/**/*.ts", "src/**/*.tsx", "index.ts", "scripts/**/*.ts", "assistants/**/*.ts"],
+  "exclude": [
+    "playground/**",
+    "docs/**",
+    "output/**",
+    "dist/**",
+    "../contentbase/**"
+  ]
+}

package/uv.lock

@@ -0,0 +1,8 @@
+version = 1
+revision = 1
+requires-python = ">=3.11"
+
+[[package]]
+name = "luca2"
+version = "0.1.0"
+source = { virtual = "." }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022 Emil Zaripov
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/cli/cli.js

@@ -1,48 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.start = void 0;
-const yargs_1 = __importDefault(require("yargs"));
-const helpers_1 = require("yargs/helpers");
-const utils_1 = require("../utils");
-const common_1 = require("./common");
-const run_1 = require("./run");
-/**
- * @docs https://yargs.js.org/docs
- */
-const start = () => __awaiter(void 0, void 0, void 0, function* () {
-    return (0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
-        .usage("Luca's manual")
-        // run command
-        .command({
-        command: 'run',
-        describe: 'Run mass requests (see examples)',
-        handler: (args) => {
-            const { dict, url } = args;
-            (0, utils_1.showErrorIf)(!(0, utils_1.isString)(dict), '--dict is required', 'example: --dict=1_char');
-            (0, utils_1.showErrorIf)(!(0, utils_1.isString)(url), `--url is required', 'example: ${(0, common_1.getUrlMaskExample)()}`);
-            (0, run_1.run)(dict, url);
-        },
-    })
-        .example(`luca run ${(0, common_1.getUrlMaskExample)()} --dict=1_char`, `for built-in dictionaries (${utils_1.DICT_NAMES.join('|')})`)
-        .example(`luca run ${(0, common_1.getUrlMaskExample)()} --dict=./my-dict.txt`, 'for your txt dict path')
-        .command({
-        command: '*',
-        handler: () => void yargs_1.default.showHelp(),
-    })
-        .demandCommand()
-        .alias('h', 'help')
-        .alias('v', 'version').argv;
-});
-exports.start = start;

package/dist/cli/common.d.ts

@@ -1,2 +0,0 @@
-export declare const WORD_PATTERN = "{0}";
-export declare const getUrlMaskExample: (baseUrl?: string) => string;

package/dist/cli/common.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUrlMaskExample = exports.WORD_PATTERN = void 0;
-exports.WORD_PATTERN = '{0}';
-const getUrlMaskExample = (baseUrl = 'https://github.com') => `--url='${baseUrl}/${exports.WORD_PATTERN}'`;
-exports.getUrlMaskExample = getUrlMaskExample;

package/dist/cli/index.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/cli/index.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const cli_1 = require("./cli");
-(0, cli_1.start)();

package/dist/cli/run.d.ts

@@ -1 +0,0 @@
-export declare const run: (dict: string, urlMask: string) => void;

package/dist/cli/run.js

@@ -1,38 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.run = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const path_1 = require("path");
-const core_1 = require("../core");
-const write_1 = require("../core/write");
-const utils_1 = require("../utils");
-const common_1 = require("./common");
-// [x] Github username
-// [x] Npm package
-// [ ] Telegram username/botname
-// [ ] Whois small size domains
-const formatUrl = (urlMask) => {
-    if (!['http', 'https'].includes(urlMask)) {
-        return `https://${urlMask}`;
-    }
-    return urlMask;
-};
-const getUrlByMask = (urlMask) => (word) => {
-    const formatted = formatUrl(urlMask);
-    if (formatted.includes(common_1.WORD_PATTERN)) {
-        return formatted.replace(common_1.WORD_PATTERN, word);
-    }
-    return `${formatted}/${word}`;
-};
-const run = (dict, urlMask) => {
-    const isBuiltInDict = utils_1.DICT_NAMES.includes(dict);
-    const dictPath = isBuiltInDict ? (0, utils_1.getDict)(dict) : (0, path_1.resolve)(dict);
-    (0, core_1.luca)(dictPath, getUrlByMask(urlMask)).subscribe({
-        next: ({ res }) => (0, utils_1.log)(`${(0, utils_1.ifSuccessResponse)(res.status, chalk_1.default.green, chalk_1.default.red)} ${res.config.url}`)(),
-        complete: (0, utils_1.log)(`\n${chalk_1.default.green('Luca finished')} ${(0, path_1.resolve)(write_1.LUCA_LOG_PATH)}`),
-    });
-};
-exports.run = run;

package/dist/core/index.d.ts

@@ -1,4 +0,0 @@
-import { AxiosResponse } from 'axios';
-export declare const luca: (dict: string, getUrl: (word: string) => string) => import("rxjs").Observable<{
-    res: AxiosResponse<any, any>;
-}>;

package/dist/core/index.js

@@ -1,32 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.luca = void 0;
-const axios_1 = __importDefault(require("axios"));
-const rxjs_1 = require("rxjs");
-const read_1 = require("./read");
-const write_1 = require("./write");
-const luca = (dict, getUrl) => (0, read_1.parse)(dict).pipe((0, rxjs_1.concatMap)((arr) => arr.map((item) => (0, rxjs_1.of)(getUrl(item)).pipe((0, rxjs_1.delay)(500), (0, rxjs_1.map)((url) => axios_1.default.get(url)), (0, rxjs_1.mergeMap)((res) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        return yield res;
-    }
-    catch (error) {
-        return error.response;
-    }
-})), (0, rxjs_1.map)((res) => {
-    return {
-        res: res,
-    };
-}), (0, rxjs_1.tap)(({ res }) => (0, write_1.writeLog)(res.config.url, res.status))))), (0, rxjs_1.concatAll)());
-exports.luca = luca;

package/dist/core/read.d.ts

@@ -1,2 +0,0 @@
-export declare const read: (filepath: string) => import("rxjs").Observable<Promise<string | null>>;
-export declare const parse: (filepath: string) => import("rxjs").Observable<string[]>;