@soederpop/luca 0.0.2

package/scripts/scaffold.ts

@@ -0,0 +1,391 @@
+import container from '@soederpop/luca/node'
+import { join } from 'path'
+
+const { ui, fs, argv } = container
+
+type HelperType = 'feature' | 'client' | 'server' | 'endpoint'
+
+interface ScaffoldAnswers {
+  type: HelperType
+  name: string
+  description: string
+}
+
+const toPascalCase = (str: string) =>
+  str
+    .replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''))
+    .replace(/^(.)/, (_, c) => c.toUpperCase())
+
+const toCamelCase = (str: string) => {
+  const pascal = toPascalCase(str)
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1)
+}
+
+const toKebabCase = (str: string) =>
+  str
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .replace(/[\s_]+/g, '-')
+    .toLowerCase()
+
+function generateFeature(name: string, description: string): string {
+  const className = toPascalCase(name)
+  const shortcut = toCamelCase(name)
+
+  return ui.endent`
+    import { z } from 'zod'
+    import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
+    import { Feature, features } from '../feature.js'
+
+    export const ${className}StateSchema = FeatureStateSchema.extend({
+      // TODO: add state properties
+    })
+
+    export const ${className}OptionsSchema = FeatureOptionsSchema.extend({
+      // TODO: add option properties
+    })
+
+    export type ${className}State = z.infer<typeof ${className}StateSchema>
+    export type ${className}Options = z.infer<typeof ${className}OptionsSchema>
+
+    /**
+     * ${description}
+     *
+     * @extends Feature
+     */
+    export class ${className} extends Feature<${className}State, ${className}Options> {
+      static override shortcut = 'features.${shortcut}' as const
+      static override stateSchema = ${className}StateSchema
+      static override optionsSchema = ${className}OptionsSchema
+
+      override get initialState(): ${className}State {
+        return {
+          ...super.initialState,
+          // TODO: add default state values
+        }
+      }
+
+      /**
+       * TODO: describe this method.
+       *
+       * @returns {Promise<void>}
+       */
+      async doSomething(): Promise<void> {
+        // TODO: implement
+      }
+    }
+
+    export default features.register('${shortcut}', ${className})
+  `
+}
+
+function generateClient(name: string, description: string): string {
+  const className = toPascalCase(name) + 'Client'
+  const registryKey = toCamelCase(name)
+
+  return ui.endent`
+    import { z } from 'zod'
+    import { ClientStateSchema, ClientOptionsSchema } from '@soederpop/luca/schemas/base.js'
+    import {
+      type ClientsInterface,
+      clients,
+      RestClient,
+    } from '@soederpop/luca/client'
+    import { type ContainerContext } from '@soederpop/luca/container'
+
+    declare module '@soederpop/luca/client' {
+      interface AvailableClients {
+        ${registryKey}: typeof ${className}
+      }
+    }
+
+    export const ${className}StateSchema = ClientStateSchema.extend({
+      // TODO: add state properties
+    })
+
+    export const ${className}OptionsSchema = ClientOptionsSchema.extend({
+      // TODO: add option properties
+    })
+
+    export type ${className}State = z.infer<typeof ${className}StateSchema>
+    export type ${className}Options = z.infer<typeof ${className}OptionsSchema>
+
+    /**
+     * ${description}
+     *
+     * @extends RestClient
+     */
+    export class ${className}<T extends ${className}State = ${className}State> extends RestClient<T> {
+      static override shortcut = 'clients.${registryKey}' as const
+      static override stateSchema = ${className}StateSchema
+      static override optionsSchema = ${className}OptionsSchema
+
+      constructor(options: ${className}Options, context: ContainerContext) {
+        options = {
+          ...options,
+          baseURL: options.baseURL || 'https://api.example.com',
+        }
+
+        super(options as any, context)
+      }
+
+      /**
+       * TODO: describe this method.
+       *
+       * @returns {Promise<any>}
+       */
+      async fetchSomething(): Promise<any> {
+        const response = await this.get('/endpoint')
+        return response.data
+      }
+    }
+
+    export default clients.register('${registryKey}', ${className})
+  `
+}
+
+function generateServer(name: string, description: string): string {
+  const className = toPascalCase(name) + 'Server'
+  const registryKey = toCamelCase(name)
+
+  return ui.endent`
+    import { z } from 'zod'
+    import { ServerStateSchema, ServerOptionsSchema } from '../schemas/base.js'
+    import type { NodeContainer } from '../node/container.js'
+    import { servers, Server, type ServersInterface, type ServerState, type StartOptions } from '../server.js'
+
+    declare module '../server' {
+      interface AvailableServers {
+        ${registryKey}: typeof ${className}
+      }
+    }
+
+    export const ${className}OptionsSchema = ServerOptionsSchema.extend({
+      // TODO: add option properties
+    })
+
+    export type ${className}Options = z.infer<typeof ${className}OptionsSchema>
+
+    /**
+     * ${description}
+     *
+     * @extends Server
+     */
+    export class ${className}<T extends ServerState = ServerState, K extends ${className}Options = ${className}Options> extends Server<T, K> {
+      static override shortcut = 'servers.${registryKey}' as const
+      static override optionsSchema = ${className}OptionsSchema
+
+      override async start(options?: StartOptions) {
+        if (this.isListening) {
+          return this
+        }
+
+        // TODO: implement server start logic
+
+        this.state.set('listening', true)
+        return this
+      }
+
+      override async stop() {
+        if (this.isStopped) {
+          return this
+        }
+
+        // TODO: implement server stop logic
+
+        this.state.set('stopped', true)
+        return this
+      }
+
+      override async configure() {
+        // TODO: implement server configuration
+
+        this.state.set('configured', true)
+        return this
+      }
+    }
+
+    export default servers.register('${registryKey}', ${className})
+  `
+}
+
+function generateEndpoint(name: string, description: string): string {
+  const kebab = toKebabCase(name)
+  const path = `/${kebab}`
+
+  return ui.endent`
+    import { z } from 'zod'
+    import type { EndpointContext } from '../../endpoint.js'
+
+    export const path = '${path}'
+    export const description = '${description}'
+    export const tags = ['${kebab}']
+
+    export const postSchema = z.object({
+      // TODO: define your parameters
+    })
+
+    export async function post(parameters: z.infer<typeof postSchema>, ctx: EndpointContext) {
+      const { container } = ctx
+      // TODO: implement
+      return { ok: true }
+    }
+  `
+}
+
+const generators: Record<HelperType, (name: string, desc: string) => string> = {
+  feature: generateFeature,
+  client: generateClient,
+  server: generateServer,
+  endpoint: generateEndpoint,
+}
+
+const outputPaths: Record<HelperType, (name: string) => string> = {
+  feature: (name) => join('src', 'node', 'features', `${toKebabCase(name)}.ts`),
+  client: (name) => join('src', 'clients', toKebabCase(name), 'index.ts'),
+  server: (name) => join('src', 'servers', `${toKebabCase(name)}.ts`),
+  endpoint: (name) => join('src', 'agi', 'endpoints', `${toKebabCase(name)}.ts`),
+}
+
+async function main() {
+  console.log(ui.banner('Scaffold', { font: 'Small', colors: ['cyan', 'blue', 'magenta'] }))
+  console.log()
+
+  // Support passing type and name as positional args: bun scripts/scaffold.ts feature myThing
+  const positionalType = argv._?.[0] as HelperType | undefined
+  const positionalName = argv._?.[1] as string | undefined
+
+  const answers = await ui.wizard([
+    {
+      type: 'list',
+      name: 'type',
+      message: 'What do you want to scaffold?',
+      choices: [
+        { name: 'Feature  - registered in FeaturesRegistry, enable/disable lifecycle', value: 'feature' },
+        { name: 'Client   - registered in ClientsRegistry, connect/configure lifecycle', value: 'client' },
+        { name: 'Server   - registered in ServersRegistry, start/stop/configure lifecycle', value: 'server' },
+        { name: 'Endpoint - file-based HTTP endpoint, Remix-like DX', value: 'endpoint' },
+      ],
+      when: () => !positionalType,
+    },
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Name (camelCase or kebab-case):',
+      validate: (input: string) => (input.trim().length > 0 ? true : 'Name is required'),
+      when: () => !positionalName,
+    },
+    {
+      type: 'input',
+      name: 'description',
+      message: 'Short description:',
+      default: 'TODO: describe this helper.',
+    },
+  ]) as Partial<ScaffoldAnswers>
+
+  const type = positionalType || answers.type!
+  const name = positionalName || answers.name!
+  const description = answers.description || 'TODO: describe this helper.'
+
+  if (!['feature', 'client', 'server', 'endpoint'].includes(type)) {
+    ui.print.red(`Invalid type "${type}". Must be feature, client, server, or endpoint.`)
+    process.exit(1)
+  }
+
+  const code = generators[type](name, description)
+  const relativePath = outputPaths[type](name)
+  const fullPath = container.paths.resolve(relativePath)
+
+  if (await fs.existsAsync(fullPath)) {
+    ui.print.red(`File already exists: ${relativePath}`)
+    process.exit(1)
+  }
+
+  const dir = container.paths.dirname(fullPath)
+  await fs.ensureFolder(dir)
+  await fs.writeFileAsync(fullPath, code + '\n')
+
+  console.log()
+  ui.print.green(`Created ${relativePath}`)
+  console.log()
+
+  if (type === 'feature') {
+    const className = toPascalCase(name)
+    const shortcut = toCamelCase(name)
+    const kebab = toKebabCase(name)
+
+    ui.print.yellow('Next steps for your new Feature:')
+    console.log()
+    console.log(ui.endent`
+      1. Add the side-effect import in src/node/container.ts:
+         ${ui.colors.cyan(`import './features/${kebab}'`)}
+
+      2. Add the type import:
+         ${ui.colors.cyan(`import type { ${className} } from './features/${kebab}'`)}
+
+      3. Add to NodeFeatures interface:
+         ${ui.colors.cyan(`${shortcut}: typeof ${className}`)}
+
+      4. Add to the export block:
+         ${ui.colors.cyan(`type ${className}`)}
+
+      5. Optionally add as a property on NodeContainer:
+         ${ui.colors.cyan(`${shortcut}?: ${className}`)}
+    `)
+  } else if (type === 'client') {
+    const className = toPascalCase(name) + 'Client'
+    const kebab = toKebabCase(name)
+
+    ui.print.yellow('Next steps for your new Client:')
+    console.log()
+    console.log(ui.endent`
+      1. Update the baseURL in src/clients/${kebab}/index.ts
+
+      2. Import and register in your script or container setup:
+         ${ui.colors.cyan(`import '@/clients/${kebab}'`)}
+
+      3. Use it:
+         ${ui.colors.cyan(`const client = container.client('${toCamelCase(name)}', { ... })`)}
+    `)
+  } else if (type === 'server') {
+    const className = toPascalCase(name) + 'Server'
+    const kebab = toKebabCase(name)
+
+    ui.print.yellow('Next steps for your new Server:')
+    console.log()
+    console.log(ui.endent`
+      1. Import and register the server in src/server.ts:
+         ${ui.colors.cyan(`import { ${className} } from './servers/${kebab}.js'`)}
+         ${ui.colors.cyan(`servers.register('${toCamelCase(name)}', ${className})`)}
+
+      2. Use it:
+         ${ui.colors.cyan(`const server = container.server('${toCamelCase(name)}', { port: 3000 })`)}
+         ${ui.colors.cyan(`await server.configure()`)}
+         ${ui.colors.cyan(`await server.start()`)}
+    `)
+  } else if (type === 'endpoint') {
+    const kebab = toKebabCase(name)
+
+    ui.print.yellow('Next steps for your new Endpoint:')
+    console.log()
+    console.log(ui.endent`
+      1. Edit the endpoint file at src/agi/endpoints/${kebab}.ts
+
+      2. Define your Zod schemas and handler functions (get, post, put, patch, delete)
+
+      3. It will be auto-loaded when useEndpoints() scans the endpoints directory:
+         ${ui.colors.cyan(`await expressServer.useEndpoints('src/agi/endpoints')`)}
+
+      4. Or load it manually:
+         ${ui.colors.cyan(`const ep = new Endpoint({ path: '/${kebab}', filePath: '...' }, container.context)`)}
+         ${ui.colors.cyan(`await ep.load()`)}
+         ${ui.colors.cyan(`expressServer.useEndpoint(ep)`)}
+    `)
+  }
+
+  console.log()
+}
+
+main().catch((err) => {
+  ui.print.red(err.message)
+  process.exit(1)
+})

package/scripts/scratch.ts

@@ -0,0 +1,15 @@
+import container from '@soederpop/luca/agi'
+
+const fs = container.feature('fs')
+
+const data = await fs.readJson('package.json') as { name: string, version: string }
+
+console.log(data.name)
+
+const info = container.feature('git').branch
+
+console.log(info)
+
+const opener = container.feature('opener')
+
+await opener.open('https://www.tiktok.com')

package/scripts/test-command-listener.ts

@@ -0,0 +1,123 @@
+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))
+})

package/scripts/test-window-manager-lifecycle.ts

@@ -0,0 +1,86 @@
+import { NodeContainer } from '../src/node/container'
+
+const args = new Set(process.argv.slice(2))
+const socketArg = process.argv.slice(2).find((arg) => arg.startsWith('--socket='))
+const socketPath = socketArg?.slice('--socket='.length)
+const shouldSpawnTTY = args.has('--spawn-tty')
+const shouldSpawnWindow = args.has('--spawn-window')
+
+const container = new NodeContainer({ cwd: process.cwd() })
+const wm = socketPath
+  ? container.feature('windowManager', { socketPath })
+  : container.feature('windowManager')
+
+wm.listen()
+
+const logCount = () => {
+  console.log(`[state] windowCount=${wm.state.get('windowCount')}`)
+}
+
+wm.on('clientConnected', () => {
+  console.log('[clientConnected] native launcher connected')
+})
+
+wm.on('clientDisconnected', () => {
+  console.log('[clientDisconnected] native launcher disconnected')
+})
+
+wm.on('windowAck', (msg) => {
+  console.log('[windowAck]', JSON.stringify(msg))
+  logCount()
+})
+
+wm.on('windowClosed', (msg) => {
+  console.log('[windowClosed]', JSON.stringify(msg))
+  logCount()
+})
+
+wm.on('terminalExited', (msg) => {
+  console.log('[terminalExited]', JSON.stringify(msg))
+})
+
+wm.on('message', (msg) => {
+  if (msg?.type === 'windowAck' || msg?.type === 'windowClosed' || msg?.type === 'terminalExited') {
+    return
+  }
+  console.log('[message]', JSON.stringify(msg))
+})
+
+let spawned = false
+wm.on('clientConnected', async () => {
+  if (spawned) return
+  spawned = true
+
+  if (shouldSpawnWindow) {
+    const opened = await wm.spawn({
+      url: 'https://example.com',
+      width: 900,
+      height: 620,
+    })
+    console.log('[spawn-window]', opened)
+  }
+
+  if (shouldSpawnTTY) {
+    const tty = await wm.spawnTTY({
+      command: 'zsh',
+      args: ['-lc', 'echo "window-manager lifecycle demo"; sleep 2; exit 7'],
+      title: 'WM Lifecycle Demo',
+      cols: 110,
+      rows: 32,
+      width: 960,
+      height: 620,
+      cwd: process.cwd(),
+    })
+    console.log('[spawn-tty]', tty)
+  }
+})
+
+await container.sleep(150)
+
+console.log(`[ready] listening=${wm.isListening} socket=${wm.state.get('socketPath') ?? '<unset>'}`)
+if (!wm.isListening) {
+  console.log(`[error] ${wm.state.get('lastError') ?? 'windowManager failed to bind socket'}`)
+  console.log('[hint] try: bun run scripts/test-window-manager-lifecycle.ts --socket=/tmp/ipc-window.sock')
+}
+console.log('[usage] bun run scripts/test-window-manager-lifecycle.ts [--spawn-tty] [--spawn-window] [--socket=/path/to/ipc-window.sock]')
+console.log('[ready] waiting for native app connection...')

package/scripts/test-window-manager.ts

@@ -0,0 +1,43 @@
+import { NodeContainer } from '../src/node/container'
+
+const container = new NodeContainer({ cwd: process.cwd() })
+const wm = container.feature('windowManager')
+
+await wm.listen()
+console.log('Listening:', wm.isListening)
+console.log('Socket path:', wm.state.get('socketPath'))
+
+wm.on('clientConnected', () => {
+  console.log('App connected')
+})
+
+wm.on('message', (msg) => {
+  console.log('Message from app:', msg)
+})
+
+wm.on('clientDisconnected', () => {
+  console.log('App disconnected')
+})
+
+// Wait for the app, then spawn a TTY running luca serve in the writing assistant playground
+wm.on('clientConnected', async () => {
+  const result = await wm.spawnTTY({
+    command: 'luca',
+    args: ['serve', '--any-port'],
+    cwd: '/Users/jon/@soederpop/playground/writing-assistant',
+    title: 'Writing Assistant Server',
+    cols: 120,
+    rows: 40,
+    width: 1000,
+    height: 700,
+  })
+
+  console.log('Spawned TTY:', result)
+
+  if (result.windowId) {
+    console.log(`Window ID: ${result.windowId}`)
+    console.log(`PID: ${result.pid}`)
+  }
+})
+
+console.log('Waiting for native app to connect...')