luca 2.0.0 → 3.0.2

package/src/node/container.ts

@@ -0,0 +1,409 @@
+import url from 'node:url'
+
+import { Container, type ContainerState } from "../container";
+import { State } from "../state";
+import type { FeatureOptions } from "./feature";
+import { features, Feature } from "./feature";
+import type { AvailableFeatures } from "../feature";
+import { Client, type ClientsInterface } from "../client";
+import "../clients/rest";
+import "../clients/graph";
+import "../clients/websocket";
+import { Server, type ServersInterface } from "../server";
+import "../servers/express";
+import "../servers/socket";
+import "../servers/mcp";
+import { Command, type CommandsInterface } from "../command";
+import { Endpoint, type EndpointsInterface } from "../endpoint";
+import { Selector, type SelectorsInterface } from "../selector";
+
+import minimist from "minimist";
+import { omit, kebabCase, camelCase, mapKeys, castArray } from "lodash-es";
+import { basename, parse, relative, resolve, join } from "path";
+
+import "./features/disk-cache";
+import "./features/content-db";
+import "./features/downloader";
+import "./features/transpiler";
+import "./features/file-manager";
+import "./features/fs";
+import "./features/git";
+import "./features/grep";
+import "./features/ipc-socket";
+import "./features/json-tree";
+import "./features/networking";
+import "./features/os";
+import "./features/package-finder";
+import "./features/python";
+import "./features/proc";
+import "./features/repl";
+import "./features/ui";
+import "./features/vault";
+import "./features/vm";
+import "./features/yaml-tree";
+import "./features/yaml";
+import "./features/docker";
+import "./features/runpod";
+import "./features/secure-shell";
+import "./features/ink";
+import "./features/telegram";
+import "./features/opener";
+import "./features/postgres";
+import "./features/sqlite";
+import "./features/google-auth";
+import "./features/google-drive";
+import "./features/google-sheets";
+import "./features/google-calendar";
+import "./features/google-docs";
+import "./features/google-mail";
+import "./features/nlp";
+import "./features/process-manager"
+import "./features/tts";
+import "./features/helpers";
+import "./features/container-link";
+import "./features/semantic-search";
+import "./features/dns";
+import "./features/redis";
+
+import type { ChildProcess } from "./features/proc";
+import type { DiskCache } from "./features/disk-cache";
+import type { ContentDb } from "./features/content-db";
+import type { Downloader } from "./features/downloader";
+import type { Transpiler } from "./features/transpiler";
+import type { FileManager } from "./features/file-manager";
+import type { FS } from "./features/fs";
+import type { Git } from "./features/git";
+import type { Grep } from "./features/grep";
+import type { IpcSocket } from "./features/ipc-socket";
+import type { JsonTree } from "./features/json-tree";
+import type { Networking } from "./features/networking";
+import type { OS } from "./features/os";
+import type { PackageFinder } from "./features/package-finder";
+import type { Python } from "./features/python";
+import type { Repl } from "./features/repl";
+import type { UI } from "./features/ui";
+import type { Vault } from "./features/vault";
+import type { VM } from "./features/vm";
+import type { YAML } from "./features/yaml";
+import type { YamlTree } from "./features/yaml-tree";
+import type { Docker } from './features/docker';
+import type { Runpod } from './features/runpod';
+import type { SecureShell } from './features/secure-shell';
+import type { Ink } from './features/ink';
+import type { Telegram } from './features/telegram';
+import type { Opener } from './features/opener';
+import type { Postgres } from './features/postgres';
+import type { Sqlite } from './features/sqlite';
+import type { GoogleAuth } from './features/google-auth';
+import type { GoogleDrive } from './features/google-drive';
+import type { GoogleSheets } from './features/google-sheets';
+import type { GoogleCalendar } from './features/google-calendar';
+import type { GoogleDocs } from './features/google-docs';
+import type { GoogleMail } from './features/google-mail';
+import type { NLP } from './features/nlp';
+import type { ProcessManager } from './features/process-manager'
+import type { TTS } from './features/tts';
+import type { Helpers } from './features/helpers';
+import type { ContainerLink } from './features/container-link';
+import type { SemanticSearch } from './features/semantic-search';
+import type { Dns } from './features/dns';
+import type { Redis } from './features/redis';
+export { State };
+
+export {
+  features,
+  Feature,
+  type FS,
+  type ContentDb,
+  type ChildProcess,
+  type Git,
+  type Grep,
+  type OS,
+  type Networking,
+  type UI,
+  type FileManager,
+  type DiskCache,
+  type Vault,
+  type Downloader,
+  type Docker,
+  type Runpod,
+  type SecureShell,
+  type Ink,
+  type Telegram,
+  type Opener,
+  type Postgres,
+  type Sqlite,
+  type GoogleAuth,
+  type GoogleDrive,
+  type GoogleSheets,
+  type GoogleCalendar,
+  type GoogleDocs,
+  type GoogleMail,
+  type NLP,
+  type ProcessManager,
+  type TTS,
+  type Helpers,
+  type ContainerLink,
+  type SemanticSearch,
+  type Dns,
+  type Redis,
+  type Transpiler,
+};
+
+export type { FeatureOptions };
+
+const baseArgv = minimist(process.argv.slice(2)) as Record<string, any> & {
+  _: string[];
+  cwd?: string;
+};
+const argv = {
+  ...baseArgv,
+  ...mapKeys(omit(baseArgv, "_"), (_, key) => camelCase(kebabCase(key))),
+};
+
+declare module "../container" {
+  interface ContainerArgv {
+    cwd?: string;
+    _?: string[];
+    enable?: string | string[];
+  }
+}
+
+export interface NodeFeatures extends AvailableFeatures {
+  fs: typeof FS;
+  proc: typeof ChildProcess;
+  git: typeof Git;
+  grep: typeof Grep;
+  os: typeof OS;
+  docker: typeof Docker;
+  networking: typeof Networking;
+  ui: typeof UI;
+  vm: typeof VM;
+  fileManager: typeof FileManager;
+  ipcSocket: typeof IpcSocket;
+  yamlTree: typeof YamlTree;
+  packageFinder: typeof PackageFinder;
+  repl: typeof Repl;
+  yaml: typeof YAML;
+  transpiler: typeof Transpiler;
+  diskCache: typeof DiskCache;
+  vault: typeof Vault;
+  jsonTree: typeof JsonTree;
+  downloader: typeof Downloader;
+  python: typeof Python;
+  runpod: typeof Runpod;
+  secureShell: typeof SecureShell;
+  ink: typeof Ink;
+  telegram: typeof Telegram;
+  opener: typeof Opener;
+  postgres: typeof Postgres;
+  sqlite: typeof Sqlite;
+  contentDb: typeof ContentDb;
+  googleAuth: typeof GoogleAuth;
+  googleDrive: typeof GoogleDrive;
+  googleSheets: typeof GoogleSheets;
+  googleCalendar: typeof GoogleCalendar;
+  googleDocs: typeof GoogleDocs;
+  googleMail: typeof GoogleMail;
+  nlp: typeof NLP;
+  processManager: typeof ProcessManager;
+  tts: typeof TTS;
+  helpers: typeof Helpers;
+  containerLink: typeof ContainerLink;
+  semanticSearch: typeof SemanticSearch;
+  dns: typeof Dns;
+  redis: typeof Redis;
+}
+
+export type ClientsAndServersInterface = ClientsInterface & ServersInterface & CommandsInterface & EndpointsInterface & SelectorsInterface;
+
+export interface NodeContainer extends ClientsAndServersInterface {}
+
+/*
+export interface NodeContainerState extends ContainerState {
+  // in luca.cli.ts you can set this to true and instead of displaying the help screen
+  // it will emit a 'commandMissing' event with the command name and args
+  // so that you can handle it however you want.  This allows for a CLI dx like
+  // luca literally type whatever you want and if your project wants to try and do
+  // something with it, it will try and do it.
+  captureMissingCommands?: boolean;
+}
+*/
+
+/**
+ * Server-side container for Node.js and Bun environments. Extends the base Container with
+ * file system access, process management, git integration, and other server-side capabilities.
+ *
+ * Auto-enables core features on construction: fs, proc, git, grep, os, networking, ui, vm, transpiler, helpers.
+ * Also attaches Client, Server, Command, Endpoint, and Selector helper types, providing
+ * `container.client()`, `container.server()`, `container.command()`, etc. factory methods.
+ *
+ * @example
+ * ```ts
+ * import container from 'luca/node'
+ *
+ * // File operations
+ * const content = container.fs.readFile('README.md')
+ *
+ * // Path utilities (scoped to cwd)
+ * const full = container.paths.resolve('src/index.ts')
+ *
+ * // Create a REST client
+ * const api = container.client('rest', { baseURL: 'https://api.example.com' })
+ *
+ * // Start an Express server
+ * const app = container.server('express', { port: 3000 })
+ * await app.start()
+ * ```
+ */
+export class NodeContainer<
+  Features extends NodeFeatures = NodeFeatures,
+  K extends ContainerState = ContainerState
+> extends Container<Features, K> {
+  fs!: FS;
+  git!: Git;
+  grep!: Grep;
+  proc!: ChildProcess;
+  os!: OS;
+  networking!: Networking;
+  ui!: UI;
+
+  vm!: VM;
+
+  fileManager?: FileManager;
+  ipcSocket?: IpcSocket;
+  yamlTree?: YamlTree;
+  packageFinder?: PackageFinder;
+  repl?: Repl;
+  transpiler?: Transpiler;
+  diskCache?: DiskCache;
+  vault?: Vault;
+  python?: Python;
+  ink?: Ink;
+  telegram?: Telegram;
+  opener?: Opener;
+  postgres?: Postgres;
+  sqlite?: Sqlite;
+  googleAuth?: GoogleAuth;
+  googleDrive?: GoogleDrive;
+  googleSheets?: GoogleSheets;
+  googleCalendar?: GoogleCalendar;
+  googleDocs?: GoogleDocs;
+  googleMail?: GoogleMail;
+  nlp?: NLP;
+  processManager?: ProcessManager;
+  tts?: TTS;
+  helpers!: Helpers;
+  containerLink?: ContainerLink;
+  redis?: Redis;
+
+  constructor(options: any = {}) {
+    super({ cwd: process.cwd(), ...argv, ...options });
+
+    // Bun loads .env from cwd automatically; no dotenv needed.
+
+    this.feature("fs", { enable: true });
+    this.feature("proc", { enable: true });
+    this.feature("git", { enable: true });
+    this.feature("grep", { enable: true });
+    this.feature("os", { enable: true });
+    this.feature("networking", { enable: true });
+    this.feature("ui", { enable: true });
+    this.feature("vm", { enable: true, context: {} });
+    this.feature("transpiler", { enable: true });
+    this.feature("helpers", { enable: true });
+
+    const enable = castArray(this.options.enable)
+      .filter((v) => v && v?.length)
+      .map((v) => v as keyof AvailableFeatures);
+
+    enable.forEach((feature) => {
+      if (this.features.has(feature)) {
+        this.feature(feature, { enable: true });
+      }
+    });
+
+    if (this.isBun) {
+	    this.addContext('Bun', Bun)
+    }
+
+    this.use(Client).use(Server).use(Command).use(Endpoint).use(Selector);
+  }
+
+  override get Feature() {
+    return Feature;
+  }
+
+  /** Returns the current working directory, from options or process.cwd(). */
+  get cwd(): string {
+    return this.options.cwd || process.cwd();
+  }
+
+  /** Returns the parsed package.json manifest for the current working directory. */
+  get manifest(): Record<string, any> {
+    try {
+      const packageJson = this.fs.findUp("packageon");
+
+      if (!packageJson) {
+        throw new Error("No packageon found");
+      }
+
+      const manifest = this.fs.readJson(packageJson);
+
+      return manifest;
+    } catch (error) {
+      return {
+        name: basename(this.cwd),
+        version: "0.0.0",
+        type: "module",
+      };
+    }
+  }
+
+  /** Returns the parsed command-line arguments (from minimist). */
+  get argv(): Record<string, any> & { _: string[] } {
+    return this.options as any;
+  }
+
+  /** Returns URL utility functions for parsing URIs. */
+  get urlUtils(): { parse: (uri: string) => url.UrlWithStringQuery } {
+    return {
+      parse: (uri: string) => url.parse(uri)
+    }
+  }
+
+  /** Returns path utility functions scoped to the current working directory (join, resolve, relative, dirname, parse). */
+  get paths(): { dirname: (path: string) => string; join: (...paths: string[]) => string; resolve: (...paths: string[]) => string; relative: (...paths: string[]) => string; basename: typeof basename; parse: typeof parse } {
+    const { cwd } = this;
+    return {
+      dirname(path: string) {
+        return parse(path).dir
+      },
+      join(...paths: string[]) {
+        return resolve(cwd, ...paths)
+      },
+      resolve(...paths: string[]) {
+        return resolve(cwd, ...paths);
+      },
+      relative(...paths: string[]) {
+        return relative(cwd, resolve(cwd, ...paths));
+      },
+      basename,
+      parse
+    };
+  }
+  
+  /** 
+   * In your project's luca.cli.ts you can call this method and pass it a function
+  *  and when you call an invalid command, the function will be called with the command name and args
+  *  this allows you to define your own DX behavior for handling unknown commands in your project
+    *  
+    * This is a special luca cli hook.  The function will be called with { words: string[], phrase: string, argv: any } 
+  */
+  private onMissingCommand(handler: any) {
+    // @ts-ignore
+    this.state.set('missingCommandHandler', handler)
+    
+    return this
+  }
+}

package/src/node/feature.ts

@@ -0,0 +1,13 @@
+import type { NodeFeatures, NodeContainer } from './container.js'
+import type { FeatureOptions, FeatureState } from '../feature.ts'
+import { features, Feature as UniversalFeature } from '../feature.ts'
+
+export { features }
+
+export type { FeatureState, FeatureOptions }
+
+export class Feature<T extends FeatureState = FeatureState, K extends FeatureOptions = FeatureOptions> extends UniversalFeature<T, K> {
+    override get container() : NodeContainer<NodeFeatures> {
+        return super.container as NodeContainer<NodeFeatures>
+    }
+}