@soederpop/luca 0.0.32 → 0.0.34

package/src/node/features/redis.ts

@@ -0,0 +1,446 @@
+import { z } from 'zod'
+import Redis from 'ioredis'
+import { Feature } from '../feature.js'
+import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
+import type { ContainerContext } from '../../container.js'
+
+export const RedisStateSchema = FeatureStateSchema.extend({
+  connected: z.boolean().default(false).describe('Whether the redis connection is currently open'),
+  url: z.string().default('').describe('Connection URL used for this redis feature instance'),
+  subscriberConnected: z.boolean().default(false).describe('Whether the dedicated subscriber connection is open'),
+  subscribedChannels: z.array(z.string()).default([]).describe('List of channels currently subscribed to'),
+  lastError: z.string().optional().describe('Most recent redis error message, if any'),
+})
+
+export const RedisOptionsSchema = FeatureOptionsSchema.extend({
+  url: z.string().optional().describe('Redis connection URL, e.g. redis://localhost:6379. Defaults to redis://localhost:6379'),
+  prefix: z.string().optional().describe('Key prefix applied to all get/set/del operations for namespace isolation'),
+  lazyConnect: z.boolean().default(false).describe('If true, connection is deferred until first command'),
+})
+
+export type RedisState = z.infer<typeof RedisStateSchema>
+export type RedisOptions = z.infer<typeof RedisOptionsSchema>
+
+export const RedisEventsSchema = FeatureEventsSchema.extend({
+  message: z.tuple([
+    z.string().describe('The channel name'),
+    z.string().describe('The message payload'),
+  ]).describe('When a message is received on a subscribed channel'),
+  subscribed: z.tuple([
+    z.string().describe('The channel name'),
+  ]).describe('When successfully subscribed to a channel'),
+  unsubscribed: z.tuple([
+    z.string().describe('The channel name'),
+  ]).describe('When unsubscribed from a channel'),
+  error: z.tuple([z.string().describe('The error message')]).describe('When a redis operation fails'),
+  closed: z.tuple([]).describe('When the redis connection is closed'),
+}).describe('Redis events')
+
+type MessageHandler = (channel: string, message: string) => void
+
+/**
+ * Redis feature for shared state and pub/sub communication between container instances.
+ *
+ * Wraps ioredis with a focused API for the primitives that matter most:
+ * key/value state, pub/sub messaging, and cross-instance coordination.
+ *
+ * Uses a dedicated subscriber connection for pub/sub (ioredis requirement),
+ * created lazily on first subscribe call.
+ *
+ * @example
+ * ```typescript
+ * const redis = container.feature('redis', { url: 'redis://localhost:6379' })
+ *
+ * // Shared state
+ * await redis.set('worker:status', 'active')
+ * const status = await redis.get('worker:status')
+ *
+ * // Pub/sub between instances
+ * redis.on('message', (channel, msg) => console.log(`${channel}: ${msg}`))
+ * await redis.subscribe('tasks')
+ * await redis.publish('tasks', JSON.stringify({ type: 'ping' }))
+ *
+ * // JSON helpers
+ * await redis.setJSON('config', { workers: 4, debug: true })
+ * const config = await redis.getJSON<{ workers: number }>('config')
+ * ```
+ */
+export class RedisFeature extends Feature<RedisState, RedisOptions> {
+  static override shortcut = 'features.redis' as const
+  static override stateSchema = RedisStateSchema
+  static override optionsSchema = RedisOptionsSchema
+  static override eventsSchema = RedisEventsSchema
+  static { Feature.register(this, 'redis') }
+
+  private _client: Redis
+  private _subscriber: Redis | null = null
+  private _prefix: string
+  private _messageHandlers: Map<string, Set<MessageHandler>> = new Map()
+
+  override get initialState(): RedisState {
+    return {
+      enabled: false,
+      connected: false,
+      url: '',
+      subscriberConnected: false,
+      subscribedChannels: [],
+    }
+  }
+
+  constructor(options: RedisOptions, context: ContainerContext) {
+    super(options, context)
+
+    const url = options.url || 'redis://localhost:6379'
+    this._prefix = options.prefix || ''
+
+    this._client = new Redis(url, {
+      lazyConnect: options.lazyConnect ?? false,
+      retryStrategy: (times: number) => Math.min(times * 200, 5000),
+    })
+
+    this.hide('_client')
+    this.hide('_subscriber')
+    this.hide('_messageHandlers')
+
+    this._client.on('connect', () => {
+      this.setState({ connected: true, url })
+    })
+
+    this._client.on('error', (err: Error) => {
+      this.setState({ lastError: err.message })
+      this.emit('error', err.message)
+    })
+
+    this._client.on('close', () => {
+      this.setState({ connected: false })
+    })
+
+    if (!options.lazyConnect) {
+      this.setState({ connected: true, url })
+    }
+  }
+
+  /** The underlying ioredis client for advanced operations. */
+  get client(): Redis {
+    return this._client
+  }
+
+  /** The dedicated subscriber connection, if pub/sub is active. */
+  get subscriber(): Redis | null {
+    return this._subscriber
+  }
+
+  // ── Key/Value Primitives ──────────────────────────────────────────
+
+  private _key(key: string): string {
+    return this._prefix ? `${this._prefix}:${key}` : key
+  }
+
+  /**
+   * Set a key to a string value with optional TTL.
+   *
+   * @param key - The key name
+   * @param value - The string value to store
+   * @param ttl - Optional time-to-live in seconds
+   */
+  async set(key: string, value: string, ttl?: number): Promise<void> {
+    if (ttl) {
+      await this._client.set(this._key(key), value, 'EX', ttl)
+    } else {
+      await this._client.set(this._key(key), value)
+    }
+  }
+
+  /**
+   * Get a key's value. Returns null if the key doesn't exist.
+   *
+   * @param key - The key name
+   * @returns The stored value, or null
+   */
+  async get(key: string): Promise<string | null> {
+    return this._client.get(this._key(key))
+  }
+
+  /**
+   * Delete one or more keys.
+   *
+   * @param keys - One or more key names to delete
+   * @returns Number of keys that were deleted
+   */
+  async del(...keys: string[]): Promise<number> {
+    return this._client.del(...keys.map(k => this._key(k)))
+  }
+
+  /**
+   * Check if a key exists.
+   *
+   * @param key - The key name
+   */
+  async exists(key: string): Promise<boolean> {
+    return (await this._client.exists(this._key(key))) === 1
+  }
+
+  /**
+   * Set a key's TTL in seconds.
+   *
+   * @param key - The key name
+   * @param seconds - TTL in seconds
+   */
+  async expire(key: string, seconds: number): Promise<boolean> {
+    return (await this._client.expire(this._key(key), seconds)) === 1
+  }
+
+  /**
+   * Find keys matching a glob pattern (respects prefix).
+   *
+   * @param pattern - Glob pattern, e.g. "worker:*"
+   * @returns Array of matching key names (with prefix stripped)
+   */
+  async keys(pattern: string = '*'): Promise<string[]> {
+    const results = await this._client.keys(this._key(pattern))
+    if (!this._prefix) return results
+    const strip = `${this._prefix}:`
+    return results.map(k => k.startsWith(strip) ? k.slice(strip.length) : k)
+  }
+
+  // ── JSON Helpers ──────────────────────────────────────────────────
+
+  /**
+   * Store a value as JSON.
+   *
+   * @param key - The key name
+   * @param value - Any JSON-serializable value
+   * @param ttl - Optional TTL in seconds
+   */
+  async setJSON(key: string, value: unknown, ttl?: number): Promise<void> {
+    await this.set(key, JSON.stringify(value), ttl)
+  }
+
+  /**
+   * Retrieve and parse a JSON value.
+   *
+   * @param key - The key name
+   * @returns The parsed value, or null if the key doesn't exist
+   */
+  async getJSON<T = unknown>(key: string): Promise<T | null> {
+    const raw = await this.get(key)
+    if (raw === null) return null
+    return JSON.parse(raw) as T
+  }
+
+  // ── Hash Helpers ──────────────────────────────────────────────────
+
+  /**
+   * Set fields on a hash.
+   *
+   * @param key - The hash key
+   * @param fields - Object of field/value pairs
+   */
+  async hset(key: string, fields: Record<string, string>): Promise<void> {
+    await this._client.hset(this._key(key), fields)
+  }
+
+  /**
+   * Get all fields from a hash.
+   *
+   * @param key - The hash key
+   * @returns Object of field/value pairs
+   */
+  async hgetall(key: string): Promise<Record<string, string>> {
+    return this._client.hgetall(this._key(key))
+  }
+
+  /**
+   * Get a single field from a hash.
+   *
+   * @param key - The hash key
+   * @param field - The field name
+   */
+  async hget(key: string, field: string): Promise<string | null> {
+    return this._client.hget(this._key(key), field)
+  }
+
+  // ── Pub/Sub ───────────────────────────────────────────────────────
+
+  /**
+   * Ensures the dedicated subscriber connection exists.
+   * ioredis requires a separate connection for subscriptions.
+   */
+  private _ensureSubscriber(): Redis {
+    if (this._subscriber) return this._subscriber
+
+    const url = this.state.get('url') || 'redis://localhost:6379'
+    this._subscriber = new Redis(url)
+
+    this._subscriber.on('message', (channel: string, message: string) => {
+      this.emit('message', channel, message)
+
+      const handlers = this._messageHandlers.get(channel)
+      if (handlers) {
+        for (const handler of handlers) {
+          handler(channel, message)
+        }
+      }
+    })
+
+    this._subscriber.on('connect', () => {
+      this.setState({ subscriberConnected: true })
+    })
+
+    this._subscriber.on('error', (err: Error) => {
+      this.setState({ lastError: err.message })
+      this.emit('error', err.message)
+    })
+
+    this._subscriber.on('close', () => {
+      this.setState({ subscriberConnected: false })
+    })
+
+    this.setState({ subscriberConnected: true })
+    return this._subscriber
+  }
+
+  /**
+   * Subscribe to one or more channels.
+   *
+   * Optionally pass a handler that fires only for these channels.
+   * The feature also emits a `message` event for all messages.
+   *
+   * @param channels - Channel name(s) to subscribe to
+   * @param handler - Optional per-channel message handler
+   *
+   * @example
+   * ```typescript
+   * await redis.subscribe('tasks', (channel, msg) => {
+   *   console.log(`Got ${msg} on ${channel}`)
+   * })
+   * ```
+   */
+  async subscribe(channels: string | string[], handler?: MessageHandler): Promise<void> {
+    const sub = this._ensureSubscriber()
+    const list = Array.isArray(channels) ? channels : [channels]
+
+    await sub.subscribe(...list)
+
+    const current = this.state.get('subscribedChannels') || []
+    const next = [...new Set([...current, ...list])]
+    this.setState({ subscribedChannels: next })
+
+    if (handler) {
+      for (const ch of list) {
+        if (!this._messageHandlers.has(ch)) {
+          this._messageHandlers.set(ch, new Set())
+        }
+        this._messageHandlers.get(ch)!.add(handler)
+      }
+    }
+
+    for (const ch of list) {
+      this.emit('subscribed', ch)
+    }
+  }
+
+  /**
+   * Unsubscribe from one or more channels.
+   *
+   * @param channels - Channel name(s) to unsubscribe from
+   */
+  async unsubscribe(...channels: string[]): Promise<void> {
+    if (!this._subscriber) return
+
+    await this._subscriber.unsubscribe(...channels)
+
+    const current = this.state.get('subscribedChannels') || []
+    this.setState({
+      subscribedChannels: current.filter((ch: string) => !channels.includes(ch)),
+    })
+
+    for (const ch of channels) {
+      this._messageHandlers.delete(ch)
+      this.emit('unsubscribed', ch)
+    }
+  }
+
+  /**
+   * Publish a message to a channel.
+   *
+   * @param channel - The channel to publish to
+   * @param message - The message string (use JSON.stringify for objects)
+   * @returns Number of subscribers that received the message
+   */
+  async publish(channel: string, message: string): Promise<number> {
+    return this._client.publish(channel, message)
+  }
+
+  // ── Docker Convenience ──────────────────────────────────────────
+
+  /**
+   * Spin up a local Redis instance via Docker. Checks if a container with
+   * the given name already exists and starts it if stopped, or creates a
+   * new one from redis:alpine.
+   *
+   * Requires the docker feature to be available on the container.
+   *
+   * @param options - Container name and host port
+   * @returns The docker container ID
+   *
+   * @example
+   * ```typescript
+   * const redis = container.feature('redis', { url: 'redis://localhost:6379', lazyConnect: true })
+   * await redis.ensureLocalDocker()
+   * ```
+   */
+  async ensureLocalDocker(options: { name?: string; port?: number; image?: string } = {}): Promise<string> {
+    const { name = 'luca-redis', port = 6379, image = 'redis:alpine' } = options
+    const docker = this.container.feature('docker', { enable: true })
+
+    const containers = await docker.listContainers({ all: true })
+    const existing = containers.find((c: any) =>
+      c.names?.includes(name) || c.names?.includes(`/${name}`)
+    )
+
+    if (existing) {
+      if (existing.state !== 'running') {
+        await docker.startContainer(name)
+      }
+      return existing.id
+    }
+
+    return docker.runContainer(image, {
+      name,
+      ports: [`${port}:6379`],
+      detach: true,
+      restart: 'unless-stopped',
+    })
+  }
+
+  // ── Lifecycle ─────────────────────────────────────────────────────
+
+  /**
+   * Close all redis connections (main client + subscriber).
+   */
+  async close(): Promise<this> {
+    if (this._subscriber) {
+      this._subscriber.disconnect()
+      this._subscriber = null
+    }
+    this._client.disconnect()
+    this._messageHandlers.clear()
+    this.setState({
+      connected: false,
+      subscriberConnected: false,
+      subscribedChannels: [],
+    })
+    this.emit('closed')
+    return this
+  }
+}
+
+export { RedisFeature as Redis }
+export default RedisFeature
+
+declare module '../../feature.js' {
+  interface AvailableFeatures {
+    redis: typeof RedisFeature
+  }
+}

package/src/node/features/ui.ts

@@ -3,13 +3,7 @@ import { FeatureStateSchema } from '../../schemas/base.js'
 import { Feature } from "../feature.js";
 import colors from "chalk";
 import type { Fonts } from "figlet";
-
-let figlet: typeof import("figlet").default | null = null;
-try {
-  figlet = require("figlet");
-} catch {
-  // figlet not installed — asciiArt/banner will fall back to plain text
-}
+import { figlet, fontNames } from "./figlet-fonts.js";
 import inquirer from "inquirer";
 import { marked } from 'marked';
 import { markedTerminal } from 'marked-terminal';
@@ -257,8 +251,8 @@ export class UI<T extends UIState = UIState> extends Feature<T> {
   get fonts(): string[] {
     const fonts = this.state.get("fonts")! || [];
 
-    if (!fonts.length && figlet) {
-      this.state.set("fonts", figlet.fontsSync());
+    if (!fonts.length) {
+      this.state.set("fonts", fontNames);
     }
 
     return this.state.get("fonts")!;
@@ -430,8 +424,7 @@ export class UI<T extends UIState = UIState> extends Feature<T> {
    * ```
    */
   asciiArt(text: string, font: Fonts): string {
-    if (!figlet) return text;
-    return figlet.textSync(text, font);
+    return figlet.textSync(text, font as any);
   }
 
   /**

package/src/python/bridge.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+"""Luca Python Bridge - persistent interactive Python session.
+
+Communicates via JSON lines over stdin/stdout. Each request is a single
+JSON object per line on stdin; each response is a single JSON object per
+line on stdout. User print() output is captured per-execution via
+io.StringIO so it never corrupts the protocol.
+
+Python 3.8+ compatible (stdlib only).
+"""
+import sys
+import json
+import io
+import traceback
+import os
+
+# Persistent namespace shared across all exec/eval calls
+_namespace = {"__builtins__": __builtins__}
+
+
+def setup_sys_path(project_dir):
+    """Insert project_dir and common sub-paths into sys.path."""
+    paths_to_add = [project_dir]
+
+    # src/ layout (PEP 621 / setuptools)
+    src_dir = os.path.join(project_dir, "src")
+    if os.path.isdir(src_dir):
+        paths_to_add.append(src_dir)
+
+    # lib/ layout (less common but exists)
+    lib_dir = os.path.join(project_dir, "lib")
+    if os.path.isdir(lib_dir):
+        paths_to_add.append(lib_dir)
+
+    for p in reversed(paths_to_add):
+        if p not in sys.path:
+            sys.path.insert(0, p)
+
+
+def _safe_serialize(value):
+    """Attempt JSON serialization; fall back to repr()."""
+    try:
+        json.dumps(value, default=str)
+        return value
+    except (TypeError, ValueError, OverflowError):
+        return repr(value)
+
+
+def handle_exec(req):
+    """Execute code in the persistent namespace."""
+    code = req.get("code", "")
+    variables = req.get("variables", {})
+    _namespace.update(variables)
+
+    old_stdout = sys.stdout
+    captured = io.StringIO()
+    sys.stdout = captured
+    try:
+        exec(code, _namespace)
+        sys.stdout = old_stdout
+        return {"ok": True, "stdout": captured.getvalue(), "result": None}
+    except Exception as e:
+        sys.stdout = old_stdout
+        return {
+            "ok": False,
+            "error": str(e),
+            "traceback": traceback.format_exc(),
+            "stdout": captured.getvalue(),
+        }
+
+
+def handle_eval(req):
+    """Evaluate an expression and return its value."""
+    expression = req.get("expression", "")
+
+    old_stdout = sys.stdout
+    captured = io.StringIO()
+    sys.stdout = captured
+    try:
+        result = eval(expression, _namespace)
+        sys.stdout = old_stdout
+        return {
+            "ok": True,
+            "result": _safe_serialize(result),
+            "stdout": captured.getvalue(),
+        }
+    except Exception as e:
+        sys.stdout = old_stdout
+        return {
+            "ok": False,
+            "error": str(e),
+            "traceback": traceback.format_exc(),
+            "stdout": captured.getvalue(),
+        }
+
+
+def handle_import(req):
+    """Import a module into the namespace."""
+    module_name = req.get("module", "")
+    alias = req.get("alias", module_name.split(".")[-1])
+    try:
+        mod = __import__(
+            module_name,
+            fromlist=[module_name.split(".")[-1]] if "." in module_name else [],
+        )
+        _namespace[alias] = mod
+        return {"ok": True, "result": "Imported {} as {}".format(module_name, alias)}
+    except Exception as e:
+        return {
+            "ok": False,
+            "error": str(e),
+            "traceback": traceback.format_exc(),
+        }
+
+
+def handle_call(req):
+    """Call a function by dotted path in the namespace."""
+    func_path = req.get("function", "")
+    args = req.get("args", [])
+    kwargs = req.get("kwargs", {})
+
+    old_stdout = sys.stdout
+    captured = io.StringIO()
+    sys.stdout = captured
+    try:
+        parts = func_path.split(".")
+        obj = _namespace[parts[0]]
+        for part in parts[1:]:
+            obj = getattr(obj, part)
+        result = obj(*args, **kwargs)
+        sys.stdout = old_stdout
+        return {
+            "ok": True,
+            "result": _safe_serialize(result),
+            "stdout": captured.getvalue(),
+        }
+    except Exception as e:
+        sys.stdout = old_stdout
+        return {
+            "ok": False,
+            "error": str(e),
+            "traceback": traceback.format_exc(),
+            "stdout": captured.getvalue(),
+        }
+
+
+def handle_get_locals(req):
+    """Return all non-dunder keys from the namespace."""
+    safe = {}
+    for k, v in _namespace.items():
+        if k.startswith("__"):
+            continue
+        safe[k] = _safe_serialize(v)
+    return {"ok": True, "result": safe}
+
+
+def handle_reset(req):
+    """Clear the namespace."""
+    _namespace.clear()
+    _namespace["__builtins__"] = __builtins__
+    return {"ok": True, "result": "Session reset"}
+
+
+HANDLERS = {
+    "exec": handle_exec,
+    "eval": handle_eval,
+    "import": handle_import,
+    "call": handle_call,
+    "get_locals": handle_get_locals,
+    "reset": handle_reset,
+}
+
+
+def main():
+    # First line from stdin is the init handshake with project_dir
+    init_line = sys.stdin.readline().strip()
+    if init_line:
+        try:
+            init = json.loads(init_line)
+            if "project_dir" in init:
+                setup_sys_path(init["project_dir"])
+        except json.JSONDecodeError:
+            pass
+
+    # Signal ready
+    sys.stdout.write(json.dumps({"ok": True, "type": "ready"}) + "\n")
+    sys.stdout.flush()
+
+    # Main loop: read JSON commands, execute, respond
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+
+        try:
+            req = json.loads(line)
+        except json.JSONDecodeError as e:
+            resp = {"ok": False, "error": "Invalid JSON: {}".format(e)}
+            sys.stdout.write(json.dumps(resp) + "\n")
+            sys.stdout.flush()
+            continue
+
+        req_id = req.get("id")
+        req_type = req.get("type", "exec")
+        handler = HANDLERS.get(req_type)
+
+        if not handler:
+            resp = {"ok": False, "error": "Unknown request type: {}".format(req_type)}
+        else:
+            resp = handler(req)
+
+        if req_id:
+            resp["id"] = req_id
+
+        sys.stdout.write(json.dumps(resp, default=str) + "\n")
+        sys.stdout.flush()
+
+
+if __name__ == "__main__":
+    main()