@soederpop/luca 0.1.3 → 0.2.2

package/commands/release.ts

@@ -1,186 +1,80 @@
-import { z } from 'zod'
-import type { ContainerContext } from '@soederpop/luca'
-import { CommandOptionsSchema } from '@soederpop/luca/schemas'
-
-const TARGETS = [
-	{ name: 'linux-x64', bunTarget: 'bun-linux-x64', suffix: 'linux-x64' },
-	{ name: 'linux-arm64', bunTarget: 'bun-linux-arm64', suffix: 'linux-arm64' },
-	{ name: 'darwin-x64', bunTarget: 'bun-darwin-x64', suffix: 'darwin-x64' },
-	{ name: 'darwin-arm64', bunTarget: 'bun-darwin-arm64', suffix: 'darwin-arm64' },
-	{ name: 'windows-x64', bunTarget: 'bun-windows-x64', suffix: 'windows-x64', ext: '.exe' },
-]
+import { z } from "zod";
+import type { ContainerContext } from "@soederpop/luca";
+import { CommandOptionsSchema } from "@soederpop/luca/schemas";
 
 export const argsSchema = CommandOptionsSchema.extend({
-	dryRun: z.boolean().optional().describe('Build binaries but skip tagging and uploading'),
-	skipBuild: z.boolean().optional().describe('Skip pre-build steps (introspection, scaffolds, bootstrap)'),
-	skipTests: z.boolean().optional().describe('Skip running tests before release'),
-	draft: z.boolean().optional().describe('Create the GitHub release as a draft'),
-	targets: z.string().optional().describe('Comma-separated list of targets to build (e.g. linux-x64,darwin-arm64). Defaults to all'),
-})
-
-async function release(options: z.infer<typeof argsSchema>, context: ContainerContext) {
-	const container = context.container as any
-	const proc = container.feature('proc')
-	const fileSystem = container.feature('fs')
-	const ui = container.feature('ui')
-
-	const pkg = JSON.parse(await fileSystem.readFileAsync('package.json'))
-	const version = pkg.version
-	const tag = `v${version}`
-	const distDir = 'dist/release'
-
-	ui.banner(`Luca Release ${tag}`)
-
-	// Filter targets if specified
-	let selectedTargets = TARGETS
-	if (options.targets) {
-		const requested = options.targets.split(',').map((t: string) => t.trim())
-		selectedTargets = TARGETS.filter(t => requested.includes(t.suffix) || requested.includes(t.name))
-		if (selectedTargets.length === 0) {
-			console.error(`No valid targets found. Available: ${TARGETS.map(t => t.suffix).join(', ')}`)
-			return
-		}
-	}
-
-	// 1. Run tests
-	if (!options.skipTests) {
-		console.log('\n→ Running tests...')
-		const testResult = await proc.execAndCapture('bun test test/*.test.ts', { silent: false })
-		if (testResult.exitCode !== 0) {
-			console.error('Tests failed. Fix them before releasing.')
-			return
-		}
-	}
-
-	// 2. Pre-build steps
-	if (!options.skipBuild) {
-		console.log('\n→ Running pre-build steps...')
-		const steps = [
-			['build:introspection', 'bun run build:introspection'],
-			['build:scaffolds', 'bun run build:scaffolds'],
-			['build:bootstrap', 'bun run build:bootstrap'],
-		]
-		for (const [label, cmd] of steps) {
-			console.log(`  ${label}...`)
-			const r = await proc.execAndCapture(cmd, { silent: true })
-			if (r.exitCode !== 0) {
-				console.error(`${label} failed:\n${r.stderr}`)
-				return
-			}
-		}
-	}
-
-	// 3. Cross-compile for all targets
-	fileSystem.ensureFolder(distDir)
-
-	console.log(`\n→ Compiling for ${selectedTargets.length} targets...`)
-	for (const target of selectedTargets) {
-		const ext = target.ext || ''
-		const outfile = `${distDir}/luca-${target.suffix}${ext}`
-		const cmd = `bun build ./src/cli/cli.ts --compile --target=${target.bunTarget} --outfile ${outfile} --external node-llama-cpp`
-
-		console.log(`  ${target.name}...`)
-		const result = await proc.execAndCapture(cmd, { silent: true })
-		if (result.exitCode !== 0) {
-			console.error(`  Failed to compile for ${target.name}:\n${result.stderr}`)
-			return
-		}
-
-		const sizeBytes = proc.exec(`stat -f%z ${container.paths.resolve(outfile)}`)
-		const sizeMB = (parseInt(sizeBytes, 10) / 1024 / 1024).toFixed(1)
-		console.log(`  ✓ ${outfile} (${sizeMB} MB)`)
-	}
-
-	if (options.dryRun) {
-		console.log(`\n→ Dry run complete. Binaries are in ${distDir}/`)
-		console.log('  Skipping git tag and GitHub release.')
-		return
-	}
-
-	// 4. Check if tag already exists
-	const tagCheck = await proc.execAndCapture(`git tag -l "${tag}"`, { silent: true })
-	if (tagCheck.stdout.trim() === tag) {
-		console.error(`\nTag ${tag} already exists. Bump the version in package.json first.`)
-		return
-	}
-
-	// 5. Check for clean working tree (allow untracked)
-	const statusCheck = await proc.execAndCapture('git status --porcelain', { silent: true })
-	const dirtyFiles = statusCheck.stdout.trim().split('\n').filter((l: string) => l && !l.startsWith('??'))
-	if (dirtyFiles.length > 0) {
-		console.error('\nWorking tree has uncommitted changes. Commit or stash them first.')
-		console.error(dirtyFiles.join('\n'))
-		return
-	}
-
-	// 6. Create git tag
-	console.log(`\n→ Creating tag ${tag}...`)
-	const tagResult = await proc.execAndCapture(`git tag -a "${tag}" -m "Release ${tag}"`, { silent: true })
-	if (tagResult.exitCode !== 0) {
-		console.error(`Failed to create tag:\n${tagResult.stderr}`)
-		return
-	}
-
-	// 7. Push tag
-	console.log(`→ Pushing tag ${tag}...`)
-	const pushResult = await proc.execAndCapture(`git push origin "${tag}"`, { silent: true })
-	if (pushResult.exitCode !== 0) {
-		console.error(`Failed to push tag:\n${pushResult.stderr}`)
-		return
-	}
-
-	// 8. Create GitHub release and upload binaries
-	const assetPaths = selectedTargets
-		.map(t => container.paths.resolve(`${distDir}/luca-${t.suffix}${t.ext || ''}`))
-
-	const releaseTitle = `Luca ${tag}`
-	const releaseNotes = await generateReleaseNotes(proc, tag)
-
-	// Write notes to a temp file so gh doesn't need shell quoting
-	const notesFile = container.paths.resolve(distDir, 'release-notes.md')
-	await fileSystem.writeFileAsync(notesFile, releaseNotes)
-
-	console.log(`\n→ Creating GitHub release ${tag}...`)
-	const ghArgs = [
-		'release', 'create', tag,
-		...assetPaths,
-		'--title', releaseTitle,
-		'--notes-file', notesFile,
-		...(options.draft ? ['--draft'] : []),
-	]
-	const ghResult = await proc.spawnAndCapture('gh', ghArgs)
-
-	if (ghResult.exitCode !== 0) {
-		console.error(`Failed to create GitHub release:\n${ghResult.stderr}`)
-		console.log('The tag was pushed. You can manually create the release with:')
-		console.log(`  gh release create ${tag} ${assetPaths.join(' ')}`)
-		return
-	}
-
-	console.log(`\n✓ Released ${tag} successfully!`)
-	console.log(`  https://github.com/soederpop/luca/releases/tag/${tag}`)
-}
-
-async function generateReleaseNotes(proc: any, tag: string): Promise<string> {
-	// Get commits since last tag
-	const lastTag = await proc.execAndCapture('git describe --tags --abbrev=0 HEAD^ 2>/dev/null || echo ""', { silent: true })
-	const since = lastTag.stdout.trim()
-
-	let logCmd: string
-	if (since) {
-		logCmd = `git log ${since}..HEAD --oneline --no-decorate`
-	} else {
-		logCmd = 'git log --oneline --no-decorate -20'
-	}
-
-	const log = await proc.execAndCapture(logCmd, { silent: true })
-	const commits = log.stdout.trim()
-
-	return `## What's Changed\n\n${commits ? commits.split('\n').map((c: string) => `- ${c}`).join('\n') : 'Initial release'}\n\n## Platforms\n\n- Linux x64\n- Linux ARM64\n- macOS x64 (Intel)\n- macOS ARM64 (Apple Silicon)\n- Windows x64`
+  skipTests: z
+    .boolean()
+    .optional()
+    .describe("Skip running tests before release"),
+});
+
+async function release(
+  options: z.infer<typeof argsSchema>,
+  context: ContainerContext,
+) {
+  const container = context.container as any;
+  const proc = container.feature("proc");
+  const fileSystem = container.feature("fs");
+  const ui = container.feature("ui");
+
+  const pkg = JSON.parse(await fileSystem.readFileAsync("package.json"));
+  const version = pkg.version;
+  const tag = `v${version}`;
+
+  ui.banner(`Luca Release ${tag}`);
+
+  // Check if tag already exists
+  const tagCheck = await proc.execAndCapture(`git tag -l "${tag}"`, {
+    silent: true,
+  });
+  if (tagCheck.stdout.trim() === tag) {
+    console.error(
+      `\nTag ${tag} already exists. Bump the version in package.json first.`,
+    );
+    return;
+  }
+
+  // Run tests
+  if (!options.skipTests) {
+    console.log("\n→ Running tests...");
+    const testResult = await proc.execAndCapture("bun test test/*.test.ts", {
+      silent: false,
+    });
+    if (testResult.exitCode !== 0) {
+      console.error("Tests failed. Fix them before releasing.");
+      return;
+    }
+  }
+
+  // Create and push git tag — triggers the GitHub Actions release workflow
+  console.log(`\n→ Creating tag ${tag}...`);
+  const tagResult = await proc.execAndCapture(
+    `git tag -a "${tag}" -m "Release ${tag}"`,
+    { silent: true },
+  );
+  if (tagResult.exitCode !== 0) {
+    console.error(`Failed to create tag:\n${tagResult.stderr}`);
+    return;
+  }
+
+  console.log(`→ Pushing tag ${tag}...`);
+  const pushResult = await proc.execAndCapture(`git push origin "${tag}"`, {
+    silent: true,
+  });
+  if (pushResult.exitCode !== 0) {
+    console.error(`Failed to push tag:\n${pushResult.stderr}`);
+    return;
+  }
+
+  console.log(
+    `\n✓ Tag ${tag} pushed. GitHub Actions will build, sign, and create the draft release.`,
+  );
+  console.log(`  https://github.com/soederpop/luca/actions`);
 }
 
 export default {
-	description: 'Build cross-platform binaries and publish a GitHub release tagged by version',
-	argsSchema,
-	handler: release,
-}
+  description: "Run tests and trigger a GitHub Actions release via git tag",
+  argsSchema,
+  handler: release,
+};

package/docs/CNAME

@@ -0,0 +1 @@
+luca-js.soederpop.com

package/docs/ideas/assistant-factory-pattern.md

@@ -0,0 +1,142 @@
+---
+title: Assistant Factory Pattern — Eliminate Wrapper Duplication
+status: idea
+tags: [agi, assistant, refactor, lucaCoder, autonomousAssistant]
+---
+
+# Assistant Factory Pattern
+
+## Problem
+
+`LucaCoder` and `AutonomousAssistant` both duplicate the same pattern: create an inner `Assistant`, stack tool bundles, wire a permission interceptor, forward events. The permission system, approval flow, and event forwarding are copy-pasted between them. `LucaCoder` is just `AutonomousAssistant` + coding opinions (bash tool, skill loading, project instructions).
+
+Both features **wrap** an assistant rather than **composing** one. This means every method on `Assistant` (ask, tools, messages, conversation) has to be proxied through the wrapper.
+
+## Proposal
+
+### 1. Extract the permission layer into a `use()`-able plugin
+
+The permission system (allow/ask/deny per tool, pending approvals, approval history) is just a `beforeToolCall` interceptor. It doesn't need to be a feature — it's a plugin function.
+
+```typescript
+import type { Assistant } from './assistant'
+
+interface PermissionConfig {
+  permissions?: Record<string, 'allow' | 'ask' | 'deny'>
+  defaultPermission?: 'allow' | 'ask' | 'deny'
+}
+
+function withPermissions(config: PermissionConfig = {}) {
+  return (assistant: Assistant) => {
+    const perms = config.permissions || {}
+    const defaultPerm = config.defaultPermission || 'ask'
+    const pendingResolvers = new Map<string, (d: 'approve' | 'deny') => void>()
+
+    assistant.intercept('beforeToolCall', async (ctx, next) => {
+      const policy = perms[ctx.name] || defaultPerm
+
+      if (policy === 'deny') {
+        ctx.skip = true
+        ctx.result = JSON.stringify({ blocked: true, tool: ctx.name, reason: 'Permission denied.' })
+        assistant.emit('toolBlocked', ctx.name, 'deny policy')
+        return
+      }
+
+      if (policy === 'allow') {
+        await next()
+        return
+      }
+
+      // 'ask' — emit event and block until resolved
+      const id = assistant.container.utils.uuid()
+      const decision = await new Promise<'approve' | 'deny'>((resolve) => {
+        pendingResolvers.set(id, resolve)
+        assistant.emit('permissionRequest', { id, toolName: ctx.name, args: ctx.args })
+      })
+
+      pendingResolvers.delete(id)
+
+      if (decision === 'approve') {
+        await next()
+      } else {
+        ctx.skip = true
+        ctx.result = JSON.stringify({ blocked: true, tool: ctx.name, reason: 'User denied.' })
+      }
+    })
+
+    // Expose approve/deny on the assistant instance
+    ;(assistant as any).approve = (id: string) => pendingResolvers.get(id)?.('approve')
+    ;(assistant as any).deny = (id: string) => pendingResolvers.get(id)?.('deny')
+  }
+}
+```
+
+### 2. LucaCoder becomes an assistant factory, not a wrapper
+
+Instead of owning an inner assistant and proxying everything, `LucaCoder` creates and returns a configured `Assistant`:
+
+```typescript
+export class LucaCoder extends Feature {
+  createAssistant(overrides?: Partial<AssistantOptions>): Assistant {
+    const assistant = this.container.feature('assistant', {
+      systemPrompt: this.buildSystemPrompt(),
+      ...overrides,
+    })
+
+    // This is the runtime equivalent of hooks.ts started()
+    assistant.use(this.container.feature('codingTools'))
+
+    const fileTools = this.container.feature('fileTools')
+    assistant.use(fileTools.toTools({ only: ['editFile', 'writeFile', 'deleteFile'] }))
+    fileTools.setupToolsConsumer(assistant)
+
+    assistant.use(this.container.feature('processManager'))
+    assistant.use(this.container.feature('skillsLibrary'))
+
+    // Permission layer as a plugin
+    if (this.options.permissions || this.options.defaultPermission) {
+      assistant.use(withPermissions({
+        permissions: this.options.permissions,
+        defaultPermission: this.options.defaultPermission,
+      }))
+    }
+
+    return assistant
+  }
+}
+```
+
+### 3. Usage
+
+```typescript
+// Runtime — no disk files, works in compiled binary
+const coder = container.feature('lucaCoder')
+const assistant = await coder.createAssistant()
+await assistant.ask('refactor the auth module')
+
+// With permission gating
+const coder = container.feature('lucaCoder', {
+  permissions: { editFile: 'ask', writeFile: 'ask', deleteFile: 'ask' },
+  defaultPermission: 'allow',
+})
+const assistant = await coder.createAssistant()
+assistant.on('permissionRequest', ({ id }) => assistant.approve(id))
+```
+
+### 4. AutonomousAssistant collapses
+
+`AutonomousAssistant` becomes either:
+- Deleted entirely (replaced by `withPermissions` plugin on any assistant)
+- Or a thin factory like LucaCoder but with no coding opinions — just `createAssistant()` + permissions
+
+## What This Achieves
+
+- **No duplication** — permission logic lives in one place (the plugin)
+- **No proxying** — you get back a real `Assistant`, not a wrapper that forwards `.ask()`, `.tools`, `.messages`, `.conversation`
+- **Binary-compatible** — the factory pattern doesn't need disk files, so it works in the compiled `luca` binary
+- **Composable** — `assistants/codingAssistant/hooks.ts` and `LucaCoder.createAssistant()` produce the exact same result through the same mechanism (`assistant.use()`)
+- **The folder-based assistant becomes the reference implementation** of what the factory does programmatically
+
+## Relationship to assistants/codingAssistant
+
+The disk-based `assistants/codingAssistant/` (CORE.md + hooks.ts + tools.ts) is the "editable" version. `LucaCoder.createAssistant()` is the "compiled" version. Same tools, same prompt, same behavior — one loads from files, the other is baked in code.