@soederpop/luca 0.0.6 → 0.0.8

package/docs/examples/launcher-app-command-listener.md

@@ -1,120 +0,0 @@
----
-title: "Launcher App Command Listener"
-tags: [launcherAppCommandListener, ipc, macos, voice, commands]
-lastTested: null
-lastTestPassed: null
----
-
-# launcherAppCommandListener
-
-IPC transport for receiving commands from the LucaVoiceLauncher macOS app. Listens on a Unix domain socket using NDJSON and wraps incoming commands in a `CommandHandle` for structured acknowledgement, progress, and completion.
-
-## Overview
-
-Use the `launcherAppCommandListener` feature when you need to receive and process commands from the native macOS launcher app (voice commands, hotkeys, or text input). It provides the server side of the IPC protocol: listen for the app to connect, receive command events, and respond with acknowledgements, progress updates, and results.
-
-Requires the LucaVoiceLauncher native macOS app to be running.
-
-## Enabling the Feature
-
-```ts
-const listener = container.feature('launcherAppCommandListener', {
-  autoListen: false
-})
-console.log('Command Listener feature created')
-console.log('Listening:', listener.isListening)
-console.log('Client connected:', listener.isClientConnected)
-```
-
-## API Documentation
-
-```ts
-const info = await container.features.describe('launcherAppCommandListener')
-console.log(info)
-```
-
-## Listening for Commands
-
-Start the IPC server and handle incoming commands with the `CommandHandle` API.
-
-```ts skip
-const listener = container.feature('launcherAppCommandListener', {
-  autoListen: true
-})
-
-listener.on('command', async (cmd) => {
-  console.log('Received command:', cmd.text)
-
-  cmd.ack('Working on it!')
-  // ... process the command ...
-  cmd.progress(0.5, 'Halfway there')
-  // ... finish processing ...
-  cmd.finish({ result: { action: 'completed' }, speech: 'All done!' })
-})
-```
-
-Each incoming command is wrapped in a `CommandHandle` that provides `ack()`, `progress()`, `finish()`, and `fail()` methods. The native app displays acknowledgements and speaks the `speech` text.
-
-## Command Handle Lifecycle
-
-The `CommandHandle` follows a structured lifecycle: acknowledge, optionally report progress, then finish or fail.
-
-```ts skip
-listener.on('command', async (cmd) => {
-  // Silent acknowledge
-  cmd.ack()
-
-  try {
-    // Report progress (0-1 scale)
-    cmd.progress(0.25, 'Starting...')
-    cmd.progress(0.75, 'Almost done...')
-
-    // Finish with result and optional speech
-    cmd.finish({
-      result: { data: 'some result' },
-      speech: 'Task completed successfully'
-    })
-  } catch (err) {
-    // Report failure with optional speech
-    cmd.fail({
-      error: err.message,
-      speech: 'Sorry, that failed.'
-    })
-  }
-})
-```
-
-The native app uses the `speech` field for text-to-speech feedback to the user.
-
-## Connection Events
-
-Monitor the IPC connection state.
-
-```ts skip
-listener.on('listening', () => {
-  console.log('IPC server listening on:', listener.state.socketPath)
-})
-listener.on('clientConnected', () => {
-  console.log('Launcher app connected')
-})
-listener.on('clientDisconnected', () => {
-  console.log('Launcher app disconnected')
-})
-```
-
-The `clientConnected` and `clientDisconnected` events fire as the native app connects and disconnects from the socket.
-
-## Sending Messages
-
-Send arbitrary NDJSON messages back to the connected app.
-
-```ts skip
-listener.send({ status: 'ready', message: 'Luca is online' })
-listener.send({ notification: 'Task queue empty' })
-```
-
-Use `send()` for custom protocol messages beyond the standard command lifecycle.
-
-## Summary
-
-The `launcherAppCommandListener` feature provides the IPC server for the LucaVoiceLauncher app. It receives voice, hotkey, and text commands, wrapping each in a `CommandHandle` with structured lifecycle methods (ack, progress, finish, fail). Key methods: `listen()`, `stop()`, `send()`. Key events: `command`, `clientConnected`, `clientDisconnected`.

package/docs/tasks/web-container-helper-discovery.md

@@ -1,71 +0,0 @@
----
-repeatable: false
----
-
-# Implement Helper Discovery for WebContainer
-
-The NodeContainer has a `helpers` feature (`src/node/features/helpers.ts`) that provides unified discovery across all registries. The WebContainer has no equivalent. Implement helper discovery for the web container.
-
-## Context
-
-The node `Helpers` feature provides:
-- `container.helpers.discover('features')` — scan conventional folders and register what it finds
-- `container.helpers.discoverAll()` — discover across all registry types
-- `container.helpers.available` — unified view of all registries
-- `container.helpers.lookup(type, name)` and `container.helpers.describe(type, name)`
-
-The web container has `features` and `clients` registries (Client is attached via `extension.ts`, which calls `container.use(Client)` and triggers `registerHelperType('clients', 'client')`). It has `RestClient` and `SocketClient` available. No servers, commands, or endpoints registries.
-
-## What to Build
-
-### 1. Create `src/web/features/helpers.ts`
-
-Port the node `Helpers` feature to work in the browser environment. Key differences from the node version:
-
-- **No filesystem scanning** — the browser can't scan directories. Instead, discovery should work via explicit registration or a manifest/config object that lists available helpers and their import paths.
-- **Registry scope** — cover `features` and `clients` (both already attached). The `registryMap` should reflect what the web container actually has.
-- **No dynamic `import()` from disk** — helper modules need to be bundled or loaded via URL. Consider accepting a map of `{ name: () => import('./my-feature.js') }` lazy loaders.
-- **Keep the same public API surface** — `discover()`, `discoverAll()`, `available`, `lookup()`, `describe()` should all work identically from the consumer's perspective.
-
-### 2. Register it in `src/web/extension.ts`
-
-Add the helpers feature to the web extension so it's available as `container.feature('helpers')` / `container.helpers`.
-
-### 3. Approach for Browser Discovery
-
-Since there's no filesystem to scan, discovery needs a different mechanism. Recommended approach:
-
-```typescript
-// Option A: Manifest-based discovery
-const helpers = container.feature('helpers', {
-  enable: true,
-  manifest: {
-    features: {
-      myFeature: () => import('./features/my-feature.js'),
-    }
-  }
-})
-await helpers.discoverAll()
-```
-
-This keeps the same `discover()` / `discoverAll()` API but replaces folder scanning with a lazy-import manifest. The manifest can be generated at build time by a bundler plugin or written by hand.
-
-### 4. Shared Base
-
-Look at whether a base `Helpers` class can be extracted to `src/features/helpers.ts` (universal, not node or web specific) with the shared API surface (`available`, `lookup`, `describe`, state/events schemas). Then `src/node/features/helpers.ts` and `src/web/features/helpers.ts` extend it with their environment-specific discovery strategies (filesystem vs manifest).
-
-## Files to Touch
-
-- `src/features/helpers.ts` — new, shared base class with common API
-- `src/web/features/helpers.ts` — new, web-specific discovery via manifest
-- `src/node/features/helpers.ts` — refactor to extend shared base
-- `src/web/extension.ts` — register the web helpers feature
-- `src/schemas/base.ts` — only if new shared schemas are needed
-
-## Acceptance Criteria
-
-- `container.helpers.available` works in both node and web containers
-- `container.helpers.discover('features')` works in web via manifest config
-- `container.helpers.lookup()` and `container.helpers.describe()` work in web
-- Node behavior is unchanged (existing tests still pass)
-- The shared base class eliminates duplicated logic between node and web

package/docs/todos.md

@@ -1 +0,0 @@
-- make container.start() meaningful. i like the idea of container.use() accepting in addition to the current shape, an async function and container.start() basically running all of those functions.  

package/scripts/test-command-listener.ts

@@ -1,123 +0,0 @@
-import { NodeContainer } from '../src/node/container'
-
-const container = new NodeContainer({ cwd: process.cwd() })
-const listener = container.feature('launcherAppCommandListener', {
-  autoListen: true,
-})
-
-const windowManager = container.feature('windowManager')
-
-console.log('Listening on:', listener.state.get('socketPath'))
-console.log('Waiting for native app to connect...\n')
-
-listener.enable()
-
-listener.on('clientConnected', () => {
-  console.log('[connected] Native app connected')
-})
-
-listener.on('clientDisconnected', () => {
-  console.log('[disconnected] Native app disconnected')
-})
-
-listener.on('command', async (cmd) => {
-  console.log(`[command] "${cmd.text}" (source: ${cmd.source}, id: ${cmd.id})`)
-
-  const normalizedText = String(cmd.text).toLowerCase()
-
-  if (normalizedText.includes('terminal')) {
-    await container.sleep(1000)
-    cmd.ack('Sheeeeeeeit.  I got you fam!')
-    await container.sleep(1000)
-    console.log('Spawning terminal')
-    const result = await windowManager.spawnTTY({ 
-      command: '/Users/jon/.bun/bin/bun',
-      args: ['run', '/Users/jon/@luca/src/cli/cli.ts', 'console'],
-      cwd: '/Users/jon/@soederpop',
-      title: 'The Console',
-      cols: 120,
-      rows: 40,
-      width: 1000,
-      height: 700,
-    })
-
-    await container.sleep(4000)
-
-    cmd.finish({ result: { action: 'completed', text: cmd.text }, speech: 'Check that shit out playboy. Fuckin terminal output.' })
-
-    return
-  } else if (normalizedText.includes('code')) {
-    await container.sleep(1000)
-    cmd.ack('Real talk, I feel for the homies we told to learn to code.  Now that claude is on this shit?? I mean.')
-    await container.sleep(1000)
-    console.log('Spawning terminal')
-    const result = await windowManager.spawnTTY({ 
-      command: '/Users/jon/.bun/bin/claude',
-      cwd: '/Users/jon/@soederpop',
-      title: 'Claude',
-      cols: 120,
-      rows: 80,
-      width: 1000,
-      height: 700,
-    })
-
-    await container.sleep(4000)
-
-    cmd.finish({ result: { action: 'completed', text: cmd.text }, speech: 'Good luck with claude bro.' })
-
-    return   
-  } else if (normalizedText.includes('web') || normalizedText.includes('browser')) {
-    cmd.ack('Yo.... Fuckin check this out, twin.')
-    await container.sleep(1000)
-    const result = await windowManager.spawn({
-      url: 'https://google.com',
-      width: 1000,
-      height: 700,
-    })
-
-    console.log('Web browser spawned', result)
-
-    await container.sleep(3000)
-    cmd.finish({ result: { action: 'completed', text: cmd.text }, speech: 'Motherfucker I can even launch web browsers' })
-    return
-  } else if (normalizedText.includes('write')) {
-    await container.sleep(1000)
-    cmd.ack('Aight. Sheeeit. We got a real fuckin earnest hemmingway up in here.')
-    const result = await windowManager.spawn({
-      url: 'http://localhost:3080',
-      width: 1200,
-      height: 900,
-    })
-    
-    await container.sleep(4000)
-    cmd.finish({ result: { action: 'completed', text: cmd.text }, speech: 'Let the boy COOK' })
-    return
-  } else if (normalizedText.includes('track')) {
-    await container.sleep(1000)
-    cmd.ack('Better believe it.  Aint nobody hiding from your boy.')
-
-    container.proc.spawnAndCapture('luca', ['serve', '--force', '--port', '3969', '--no-open'], {
-      cwd: '/Users/jon/@soederpop/playground/enemy-tracker'
-    })
-
-    await container.sleep(4000)
-
-    const result = await windowManager.spawn({
-      url: 'http://localhost:3969',
-      width: 1400,
-      height: 1000,
-    })
-
-    cmd.finish({ result: { action: 'completed', text: cmd.text }, speech: 'Get em dawg.  Me and the homies are ready.' })
-    
-    return
-  }
-
-  await container.sleep(4000)
-  cmd.ack('Look unc. I dont know the fuck you talmbout.')
-  cmd.finish({ result: { action: 'unknown' }})
-})
-
-listener.on('message', (msg) => {
-  console.log('[message]', JSON.stringify(msg))
-})