openrune 0.1.2 → 0.2.0

package/.mcp.json

@@ -0,0 +1,16 @@
+{
+  "mcpServers": {
+    "rune-channel": {
+      "command": "node",
+      "args": [
+        "/Users/gilhyun/IdeaProjects/Rune/dist/rune-channel.js"
+      ],
+      "env": {
+        "RUNE_FOLDER_PATH": "/Users/gilhyun/IdeaProjects/Rune",
+        "RUNE_CHANNEL_PORT": "51234",
+        "RUNE_AGENT_ROLE": "General assistant",
+        "RUNE_FILE_PATH": "/Users/gilhyun/IdeaProjects/Rune/Rune.rune"
+      }
+    }
+  }
+}

package/README.md

@@ -5,8 +5,8 @@
 <h1 align="center">Rune</h1>
 
 <p align="center">
-  <strong>File-based AI Agent Desktop App</strong><br/>
-  Drop a <code>.rune</code> file in any folder. Double-click to open. Chat with your AI agent.
+  <strong>File-based AI Agent Harness for Claude Code</strong><br/>
+  Drop a <code>.rune</code> file in any folder. Run it headlessly, chain agents, or open the desktop UI.
 </p>
 
 <p align="center">
@@ -31,11 +31,13 @@ Rune turns any folder into an AI workspace. Each `.rune` file is an independent
 
 ## Why Rune?
 
-Most AI tools lose context when you close the window. Rune doesn't — because your agent lives in your folder.
+Building a Claude Code harness usually means wiring up process management, I/O parsing, state handling, and a UI from scratch. Rune lets you skip all of that — just drop a file and go.
+
+**No harness boilerplate** — No SDK wiring, no process management, no custom I/O parsing. One `.rune` file gives you a fully working Claude Code agent with a desktop UI.
 
 **Persistent context** — Your agent remembers everything. Close the app, reopen it next week — the conversation and context are right where you left off.
 
-**Portable** — The `.rune` file is just a file. Copy it to another machine, share it with a teammate, or check it into git. Your agent goes wherever the file goes.
+**Portable** — The `.rune` file is just a JSON file. Copy it to another machine, share it with a teammate, or check it into git. Your agent goes wherever the file goes.
 
 **Multiple agents per folder** — Need a code reviewer AND a backend developer in the same project? Create two `.rune` files. Each agent has its own role, history, and expertise — working side by side in the same folder.
 
@@ -144,12 +146,78 @@ Edit the `role` field anytime to change the agent's behavior.
 | `rune install` | Build app, register file association, install Quick Action |
 | `rune new <name>` | Create a `.rune` file in the current directory |
 | `rune new <name> --role "..."` | Create with a custom role |
-| `rune open <file.rune>` | Open a `.rune` file |
+| `rune open <file.rune>` | Open a `.rune` file (desktop GUI) |
+| `rune run <file.rune> "prompt"` | Run agent headlessly (no GUI) |
+| `rune pipe <a.rune> <b.rune> "prompt"` | Chain agents in a pipeline |
+| `rune watch <file.rune> --on <event>` | Set up automated triggers |
 | `rune list` | List `.rune` files in the current directory |
 | `rune uninstall` | Remove Rune integration (keeps your `.rune` files) |
 
 ---
 
+## Harness Mode
+
+Rune isn't just a desktop app — it's a full agent harness. Use it from scripts, CI/CD, or your own tools.
+
+### Headless execution
+
+Run any `.rune` agent from the command line without opening the GUI:
+
+```bash
+rune run reviewer.rune "Review the latest commit"
+
+# Pipe input from other commands
+git diff | rune run reviewer.rune "Review this diff"
+
+# JSON output for scripting
+rune run reviewer.rune "Review src/auth.ts" --output json
+```
+
+### Agent chaining
+
+Chain multiple agents into a pipeline. The output of each agent becomes the input for the next:
+
+```bash
+rune pipe coder.rune reviewer.rune tester.rune "Implement a login page"
+```
+
+This runs: coder writes the code → reviewer reviews it → tester writes tests.
+
+### Automated triggers
+
+Set agents to run automatically on events:
+
+```bash
+# Run on every git commit
+rune watch reviewer.rune --on git-commit --prompt "Review this commit"
+
+# Watch for file changes
+rune watch linter.rune --on file-change --glob "src/**/*.ts" --prompt "Check for issues"
+
+# Run on a schedule
+rune watch monitor.rune --on cron --interval 5m --prompt "Check server health"
+```
+
+### Node.js API
+
+Use Rune agents programmatically in your own code:
+
+```js
+const rune = require('openrune')
+
+const reviewer = rune.load('reviewer.rune')
+const result = await reviewer.send('Review the latest commit')
+console.log(result)
+
+// Agent chaining via API
+const { finalOutput } = await rune.pipe(
+  ['coder.rune', 'reviewer.rune'],
+  'Implement a login page'
+)
+```
+
+---
+
 ## Architecture
 
 ```

package/bin/rune.js

@@ -29,6 +29,9 @@ switch (command) {
   case 'install': return install()
   case 'new':     return createRune(args[0], args)
   case 'open':    return openRune(args[0])
+  case 'run':     return runRune(args[0], args.slice(1))
+  case 'pipe':    return pipeRunes(args)
+  case 'watch':   return watchRune(args[0], args.slice(1))
   case 'list':    return listRunes()
   case 'uninstall': return uninstall()
   case 'help':
@@ -649,6 +652,421 @@ function openRune(file) {
   child.unref()
 }
 
+// ── run (headless) ──────────────────────────────
+
+function runRune(file, restArgs) {
+  if (!file) {
+    console.log('Usage: rune run <file.rune> "prompt" [--output json|text]')
+    console.log('Example: rune run reviewer.rune "Review the latest commit"')
+    process.exit(1)
+  }
+
+  const filePath = path.resolve(process.cwd(), file)
+  if (!fs.existsSync(filePath)) {
+    console.error(`  ❌ File not found: ${filePath}`)
+    process.exit(1)
+  }
+
+  // Parse args: prompt and flags
+  let prompt = ''
+  let outputFormat = 'text'
+  for (let i = 0; i < restArgs.length; i++) {
+    if (restArgs[i] === '--output' && restArgs[i + 1]) {
+      outputFormat = restArgs[i + 1]
+      i++
+    } else if (!prompt) {
+      prompt = restArgs[i]
+    }
+  }
+
+  // Read from stdin if no prompt provided
+  if (!prompt && process.stdin.isTTY === false) {
+    prompt = fs.readFileSync('/dev/stdin', 'utf-8').trim()
+  }
+
+  if (!prompt) {
+    console.error('  ❌ No prompt provided. Pass a prompt string or pipe via stdin.')
+    process.exit(1)
+  }
+
+  const rune = JSON.parse(fs.readFileSync(filePath, 'utf-8'))
+  const folderPath = path.dirname(filePath)
+
+  // Build system prompt from .rune context
+  const systemParts = []
+  if (rune.role) systemParts.push(`Your role: ${rune.role}`)
+  if (rune.memory && rune.memory.length > 0) {
+    systemParts.push('Saved memory from previous sessions:')
+    rune.memory.forEach((m, i) => systemParts.push(`${i + 1}. ${m}`))
+  }
+  if (rune.history && rune.history.length > 0) {
+    const recent = rune.history.slice(-10)
+    systemParts.push(`\nRecent conversation (${rune.history.length} total, showing last ${recent.length}):`)
+    for (const msg of recent) {
+      const who = msg.role === 'user' ? 'User' : 'Assistant'
+      systemParts.push(`${who}: ${msg.text}`)
+    }
+  }
+
+  const systemPrompt = systemParts.join('\n')
+
+  // Build claude CLI args
+  const claudeArgs = ['-p', '--print']
+  if (systemPrompt) {
+    claudeArgs.push('--system-prompt', systemPrompt)
+  }
+  if (outputFormat === 'json') {
+    claudeArgs.push('--output-format', 'json')
+  }
+  claudeArgs.push(prompt)
+
+  const child = spawn('claude', claudeArgs, {
+    cwd: folderPath,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env: { ...process.env },
+  })
+
+  let stdout = ''
+  let stderr = ''
+
+  child.stdout.on('data', (data) => {
+    const text = data.toString()
+    stdout += text
+    if (outputFormat !== 'json') process.stdout.write(text)
+  })
+  child.stderr.on('data', (data) => { stderr += data.toString() })
+
+  child.on('close', (code) => {
+    if (outputFormat === 'json') {
+      try {
+        const parsed = JSON.parse(stdout)
+        console.log(JSON.stringify({ agent: rune.name, role: rune.role, response: parsed }, null, 2))
+      } catch {
+        console.log(JSON.stringify({ agent: rune.name, role: rune.role, response: stdout.trim() }, null, 2))
+      }
+    }
+
+    // Save to history
+    rune.history = rune.history || []
+    rune.history.push({ role: 'user', text: prompt, ts: Date.now() })
+    rune.history.push({ role: 'assistant', text: stdout.trim(), ts: Date.now() })
+    fs.writeFileSync(filePath, JSON.stringify(rune, null, 2))
+
+    if (code !== 0 && stderr) {
+      console.error(stderr)
+    }
+    process.exit(code || 0)
+  })
+}
+
+// ── pipe (agent chaining) ───────────────────────
+
+async function pipeRunes(args) {
+  // Parse: rune pipe agent1.rune agent2.rune ... "initial prompt" [--output json]
+  const runeFiles = []
+  let prompt = ''
+  let outputFormat = 'text'
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--output' && args[i + 1]) {
+      outputFormat = args[i + 1]
+      i++
+    } else if (args[i].endsWith('.rune')) {
+      runeFiles.push(args[i])
+    } else if (!prompt) {
+      prompt = args[i]
+    }
+  }
+
+  if (runeFiles.length < 2 || !prompt) {
+    console.log('Usage: rune pipe <agent1.rune> <agent2.rune> [...] "initial prompt"')
+    console.log('Example: rune pipe coder.rune reviewer.rune "Implement a login page"')
+    console.log('\nThe output of each agent becomes the input for the next.')
+    process.exit(1)
+  }
+
+  // Read from stdin if no prompt
+  if (!prompt && process.stdin.isTTY === false) {
+    prompt = fs.readFileSync('/dev/stdin', 'utf-8').trim()
+  }
+
+  let currentInput = prompt
+  const results = []
+
+  for (let i = 0; i < runeFiles.length; i++) {
+    const file = runeFiles[i]
+    const filePath = path.resolve(process.cwd(), file)
+
+    if (!fs.existsSync(filePath)) {
+      console.error(`  ❌ File not found: ${filePath}`)
+      process.exit(1)
+    }
+
+    const rune = JSON.parse(fs.readFileSync(filePath, 'utf-8'))
+    const folderPath = path.dirname(filePath)
+
+    const isLast = i === runeFiles.length - 1
+    const pipeContext = i > 0
+      ? `You are step ${i + 1} of ${runeFiles.length} in a pipeline. The previous agent (${results[i-1].agent}) produced the following output:\n\n${currentInput}\n\nNow do your part:`
+      : currentInput
+
+    if (outputFormat !== 'json') {
+      console.error(`\n  ▶ [${i + 1}/${runeFiles.length}] ${rune.name} (${rune.role || 'assistant'})`)
+    }
+
+    // Build system prompt
+    const systemParts = []
+    if (rune.role) systemParts.push(`Your role: ${rune.role}`)
+    if (rune.memory && rune.memory.length > 0) {
+      systemParts.push('Saved memory:')
+      rune.memory.forEach((m, j) => systemParts.push(`${j + 1}. ${m}`))
+    }
+
+    const claudeArgs = ['-p', '--print']
+    if (systemParts.length > 0) {
+      claudeArgs.push('--system-prompt', systemParts.join('\n'))
+    }
+    claudeArgs.push(pipeContext)
+
+    const output = await new Promise((resolve, reject) => {
+      const child = spawn('claude', claudeArgs, {
+        cwd: folderPath,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: { ...process.env },
+      })
+
+      let stdout = ''
+      let stderr = ''
+      child.stdout.on('data', (d) => { stdout += d.toString() })
+      child.stderr.on('data', (d) => { stderr += d.toString() })
+      child.on('close', (code) => {
+        if (code !== 0) reject(new Error(stderr || `Agent ${rune.name} exited with code ${code}`))
+        else resolve(stdout.trim())
+      })
+    })
+
+    results.push({ agent: rune.name, role: rune.role, output })
+
+    // Save to .rune history
+    rune.history = rune.history || []
+    rune.history.push({ role: 'user', text: pipeContext, ts: Date.now() })
+    rune.history.push({ role: 'assistant', text: output, ts: Date.now() })
+    fs.writeFileSync(filePath, JSON.stringify(rune, null, 2))
+
+    currentInput = output
+
+    // Print intermediate output
+    if (outputFormat !== 'json' && !isLast) {
+      console.error(`  ✓ Done\n`)
+    }
+  }
+
+  // Final output
+  if (outputFormat === 'json') {
+    console.log(JSON.stringify({ pipeline: results, finalOutput: currentInput }, null, 2))
+  } else {
+    console.log(currentInput)
+  }
+}
+
+// ── watch (triggers) ────────────────────────────
+
+function watchRune(file, restArgs) {
+  if (!file) {
+    console.log('Usage: rune watch <file.rune> --on <event> [options]')
+    console.log('')
+    console.log('Events:')
+    console.log('  file-change    Watch for file changes in the project folder')
+    console.log('  git-push       Run after git push (installs a git hook)')
+    console.log('  git-commit     Run after git commit (installs a git hook)')
+    console.log('  cron           Run on a schedule (e.g. --interval 5m)')
+    console.log('')
+    console.log('Options:')
+    console.log('  --prompt "..."       The prompt to send when triggered')
+    console.log('  --glob "*.ts"        File pattern to watch (for file-change)')
+    console.log('  --interval 5m        Interval for cron (e.g. 30s, 5m, 1h)')
+    console.log('')
+    console.log('Examples:')
+    console.log('  rune watch reviewer.rune --on file-change --glob "src/**/*.ts" --prompt "Review changed files"')
+    console.log('  rune watch reviewer.rune --on git-commit --prompt "Review this commit"')
+    console.log('  rune watch monitor.rune --on cron --interval 5m --prompt "Check server status"')
+    process.exit(1)
+  }
+
+  const filePath = path.resolve(process.cwd(), file)
+  if (!fs.existsSync(filePath)) {
+    console.error(`  ❌ File not found: ${filePath}`)
+    process.exit(1)
+  }
+
+  // Parse args
+  let event = ''
+  let prompt = ''
+  let glob = ''
+  let interval = '5m'
+
+  for (let i = 0; i < restArgs.length; i++) {
+    if (restArgs[i] === '--on' && restArgs[i + 1]) { event = restArgs[++i] }
+    else if (restArgs[i] === '--prompt' && restArgs[i + 1]) { prompt = restArgs[++i] }
+    else if (restArgs[i] === '--glob' && restArgs[i + 1]) { glob = restArgs[++i] }
+    else if (restArgs[i] === '--interval' && restArgs[i + 1]) { interval = restArgs[++i] }
+  }
+
+  if (!event) {
+    console.error('  ❌ --on <event> is required')
+    process.exit(1)
+  }
+
+  if (!prompt) {
+    console.error('  ❌ --prompt is required')
+    process.exit(1)
+  }
+
+  const rune = JSON.parse(fs.readFileSync(filePath, 'utf-8'))
+  const folderPath = path.dirname(filePath)
+
+  function triggerRun(triggerInfo) {
+    const fullPrompt = triggerInfo
+      ? `[Triggered by: ${triggerInfo}]\n\n${prompt}`
+      : prompt
+    console.log(`\n🔮 [${new Date().toLocaleTimeString()}] Triggered: ${rune.name} — ${triggerInfo || event}`)
+
+    const systemParts = []
+    if (rune.role) systemParts.push(`Your role: ${rune.role}`)
+
+    const claudeArgs = ['-p', '--print']
+    if (systemParts.length > 0) {
+      claudeArgs.push('--system-prompt', systemParts.join('\n'))
+    }
+    claudeArgs.push(fullPrompt)
+
+    const child = spawn('claude', claudeArgs, {
+      cwd: folderPath,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env },
+    })
+
+    let stdout = ''
+    child.stdout.on('data', (d) => {
+      const text = d.toString()
+      stdout += text
+      process.stdout.write(text)
+    })
+    child.stderr.on('data', (d) => { process.stderr.write(d) })
+    child.on('close', () => {
+      // Save to history
+      const fresh = JSON.parse(fs.readFileSync(filePath, 'utf-8'))
+      fresh.history = fresh.history || []
+      fresh.history.push({ role: 'user', text: fullPrompt, ts: Date.now() })
+      fresh.history.push({ role: 'assistant', text: stdout.trim(), ts: Date.now() })
+      fs.writeFileSync(filePath, JSON.stringify(fresh, null, 2))
+      console.log(`\n✓ Done`)
+    })
+  }
+
+  // ── Event handlers ──
+
+  if (event === 'file-change') {
+    const watchDir = folderPath
+    console.log(`🔮 Watching ${watchDir} for file changes...`)
+    if (glob) console.log(`   Pattern: ${glob}`)
+    console.log(`   Agent: ${rune.name} (${rune.role || 'assistant'})`)
+    console.log('   Press Ctrl+C to stop\n')
+
+    let debounce = null
+    fs.watch(watchDir, { recursive: true }, (eventType, filename) => {
+      if (!filename) return
+      if (filename.endsWith('.rune')) return  // ignore .rune file changes
+      if (filename.startsWith('.git')) return
+      if (filename.includes('node_modules')) return
+
+      // Simple glob matching
+      if (glob) {
+        const ext = glob.replace('*', '')
+        if (!filename.endsWith(ext) && !filename.includes(glob.replace('*', ''))) return
+      }
+
+      // Debounce: wait 1s after last change
+      if (debounce) clearTimeout(debounce)
+      debounce = setTimeout(() => {
+        triggerRun(`file changed: ${filename}`)
+      }, 1000)
+    })
+  }
+
+  else if (event === 'git-commit' || event === 'git-push') {
+    const hookName = event === 'git-commit' ? 'post-commit' : 'post-push'
+    const gitDir = path.join(folderPath, '.git', 'hooks')
+
+    if (!fs.existsSync(path.join(folderPath, '.git'))) {
+      console.error('  ❌ Not a git repository')
+      process.exit(1)
+    }
+
+    ensureDir(gitDir)
+
+    // For git-push, use pre-push since post-push doesn't exist natively
+    const actualHook = event === 'git-push' ? 'pre-push' : 'post-commit'
+    const hookPath = path.join(gitDir, actualHook)
+    const runeBin = path.resolve(__dirname, 'rune.js')
+    const nodebin = process.execPath
+
+    const hookScript = `#!/bin/bash
+# Rune auto-trigger: ${rune.name}
+"${nodebin}" "${runeBin}" run "${filePath}" "${prompt.replace(/"/g, '\\"')}" &
+`
+
+    // Append if hook exists, create if not
+    if (fs.existsSync(hookPath)) {
+      const existing = fs.readFileSync(hookPath, 'utf-8')
+      if (!existing.includes('Rune auto-trigger')) {
+        fs.appendFileSync(hookPath, '\n' + hookScript)
+      } else {
+        console.log(`  ⚠️  Rune hook already installed in ${actualHook}`)
+        return
+      }
+    } else {
+      fs.writeFileSync(hookPath, hookScript, { mode: 0o755 })
+    }
+
+    console.log(`🔮 Git hook installed: ${actualHook}`)
+    console.log(`   Agent: ${rune.name} will run on every ${event.replace('git-', '')}`)
+    console.log(`   Prompt: "${prompt}"`)
+    console.log(`   Hook: ${hookPath}`)
+  }
+
+  else if (event === 'cron') {
+    const ms = parseInterval(interval)
+    console.log(`🔮 Running ${rune.name} every ${interval}`)
+    console.log(`   Prompt: "${prompt}"`)
+    console.log('   Press Ctrl+C to stop\n')
+
+    // Run immediately, then on interval
+    triggerRun(`cron (every ${interval})`)
+    setInterval(() => {
+      triggerRun(`cron (every ${interval})`)
+    }, ms)
+  }
+
+  else {
+    console.error(`  ❌ Unknown event: ${event}. Use: file-change, git-commit, git-push, cron`)
+    process.exit(1)
+  }
+}
+
+function parseInterval(str) {
+  const match = str.match(/^(\d+)(s|m|h)$/)
+  if (!match) {
+    console.error(`  ❌ Invalid interval: ${str}. Use format like 30s, 5m, 1h`)
+    process.exit(1)
+  }
+  const num = parseInt(match[1])
+  const unit = match[2]
+  if (unit === 's') return num * 1000
+  if (unit === 'm') return num * 60 * 1000
+  if (unit === 'h') return num * 60 * 60 * 1000
+}
+
 // ── list ─────────────────────────────────────────
 
 function listRunes() {
@@ -707,21 +1125,32 @@ function uninstall() {
 
 function showHelp() {
   console.log(`
-🔮 Rune — File-based AI Agent
+🔮 Rune — File-based AI Agent Harness
 
 Usage:
   rune install              Install Rune (build app, register file association, add Quick Action)
   rune new <name>           Create a new .rune file in current directory
     --role "description"    Set the agent's role
-  rune open <file.rune>     Open a .rune file
+  rune open <file.rune>     Open a .rune file (desktop GUI)
+  rune run <file.rune> "prompt"   Run agent headlessly (no GUI)
+    --output json|text      Output format (default: text)
+  rune pipe <a.rune> <b.rune> ... "prompt"   Chain agents in a pipeline
+    --output json|text      Output format (default: text)
+  rune watch <file.rune>    Set up automated triggers
+    --on <event>            Event: file-change, git-commit, git-push, cron
+    --prompt "..."          Prompt to send when triggered
+    --glob "*.ts"           File pattern (for file-change)
+    --interval 5m           Schedule interval (for cron: 30s, 5m, 1h)
   rune list                 List .rune files in current directory
   rune uninstall            Remove Rune integration (keeps .rune files)
   rune help                 Show this help
 
 Examples:
-  rune new designer --role "UI/UX design expert"
-  rune new backend --role "Backend developer, Node.js specialist"
-  rune open designer.rune
-  rune list
+  rune new reviewer --role "Code reviewer, security focused"
+  rune run reviewer.rune "Review the latest commit"
+  rune pipe coder.rune reviewer.rune "Implement a login page"
+  rune watch reviewer.rune --on git-commit --prompt "Review this commit"
+  rune watch monitor.rune --on cron --interval 5m --prompt "Check server health"
+  echo "Fix the bug in auth.ts" | rune run backend.rune
 `)
 }

package/channel/rune-channel.ts

@@ -50,15 +50,34 @@ function buildSessionContext(): string {
     rune.memory.forEach((m, i) => parts.push(`${i + 1}. ${m}`))
   }
 
-  // History summary (last 20 messages condensed)
+  // History: last 50 messages, recent 10 in full detail
   if (rune.history && rune.history.length > 0) {
-    const recent = rune.history.slice(-20)
-    parts.push('\n## Recent Conversation History')
+    const TOTAL_LIMIT = 50
+    const FULL_DETAIL_COUNT = 10
+    const recent = rune.history.slice(-TOTAL_LIMIT)
+    const olderMessages = recent.slice(0, -FULL_DETAIL_COUNT)
+    const recentMessages = recent.slice(-FULL_DETAIL_COUNT)
+
+    parts.push('\n## Conversation History')
     parts.push(`(${rune.history.length} total messages, showing last ${recent.length})`)
-    for (const msg of recent) {
-      const who = msg.role === 'user' ? 'User' : 'You'
-      const text = msg.text.length > 200 ? msg.text.slice(0, 200) + '...' : msg.text
-      parts.push(`- **${who}**: ${text}`)
+
+    // Older messages: summarized (truncated to 500 chars)
+    if (olderMessages.length > 0) {
+      parts.push('\n### Earlier Context')
+      for (const msg of olderMessages) {
+        const who = msg.role === 'user' ? 'User' : 'You'
+        const text = msg.text.length > 500 ? msg.text.slice(0, 500) + '...' : msg.text
+        parts.push(`- **${who}**: ${text}`)
+      }
+    }
+
+    // Recent messages: full text (no truncation)
+    if (recentMessages.length > 0) {
+      parts.push('\n### Recent Messages (Full Detail)')
+      for (const msg of recentMessages) {
+        const who = msg.role === 'user' ? 'User' : 'You'
+        parts.push(`- **${who}**: ${msg.text}`)
+      }
     }
   }
 

package/lib/index.js

@@ -0,0 +1,116 @@
+/**
+ * OpenRune — Node.js API
+ *
+ * Usage:
+ *   const rune = require('openrune')
+ *   const agent = rune.load('reviewer.rune')
+ *   const result = await agent.send('Review this code')
+ */
+
+const { spawn } = require('child_process')
+const path = require('path')
+const fs = require('fs')
+
+function load(filePath) {
+  const resolved = path.resolve(filePath)
+  if (!fs.existsSync(resolved)) {
+    throw new Error(`Rune file not found: ${resolved}`)
+  }
+
+  const rune = JSON.parse(fs.readFileSync(resolved, 'utf-8'))
+  const folderPath = path.dirname(resolved)
+
+  return {
+    name: rune.name,
+    role: rune.role,
+    filePath: resolved,
+
+    async send(prompt) {
+      const fresh = JSON.parse(fs.readFileSync(resolved, 'utf-8'))
+
+      // Build system prompt
+      const systemParts = []
+      if (fresh.role) systemParts.push(`Your role: ${fresh.role}`)
+      if (fresh.memory && fresh.memory.length > 0) {
+        systemParts.push('Saved memory:')
+        fresh.memory.forEach((m, i) => systemParts.push(`${i + 1}. ${m}`))
+      }
+      if (fresh.history && fresh.history.length > 0) {
+        const recent = fresh.history.slice(-10)
+        systemParts.push(`\nRecent conversation (last ${recent.length}):`)
+        for (const msg of recent) {
+          const who = msg.role === 'user' ? 'User' : 'Assistant'
+          systemParts.push(`${who}: ${msg.text}`)
+        }
+      }
+
+      const claudeArgs = ['-p', '--print']
+      if (systemParts.length > 0) {
+        claudeArgs.push('--system-prompt', systemParts.join('\n'))
+      }
+      claudeArgs.push(prompt)
+
+      const result = await new Promise((resolve, reject) => {
+        const child = spawn('claude', claudeArgs, {
+          cwd: folderPath,
+          stdio: ['pipe', 'pipe', 'pipe'],
+          env: { ...process.env },
+        })
+
+        let stdout = ''
+        let stderr = ''
+        child.stdout.on('data', (d) => { stdout += d.toString() })
+        child.stderr.on('data', (d) => { stderr += d.toString() })
+        child.on('close', (code) => {
+          if (code !== 0) reject(new Error(stderr || `Exit code ${code}`))
+          else resolve(stdout.trim())
+        })
+      })
+
+      // Save to history
+      fresh.history = fresh.history || []
+      fresh.history.push({ role: 'user', text: prompt, ts: Date.now() })
+      fresh.history.push({ role: 'assistant', text: result, ts: Date.now() })
+      fs.writeFileSync(resolved, JSON.stringify(fresh, null, 2))
+
+      return result
+    },
+
+    getHistory() {
+      const fresh = JSON.parse(fs.readFileSync(resolved, 'utf-8'))
+      return fresh.history || []
+    },
+
+    getMemory() {
+      const fresh = JSON.parse(fs.readFileSync(resolved, 'utf-8'))
+      return fresh.memory || []
+    },
+
+    addMemory(text) {
+      const fresh = JSON.parse(fs.readFileSync(resolved, 'utf-8'))
+      fresh.memory = fresh.memory || []
+      fresh.memory.push(text)
+      fs.writeFileSync(resolved, JSON.stringify(fresh, null, 2))
+    },
+  }
+}
+
+async function pipe(runeFiles, prompt) {
+  let currentInput = prompt
+  const results = []
+
+  for (let i = 0; i < runeFiles.length; i++) {
+    const agent = load(runeFiles[i])
+    const input = i > 0
+      ? `Previous agent (${results[i-1].agent}) output:\n\n${currentInput}\n\nNow do your part:`
+      : currentInput
+
+    const output = await agent.send(input)
+    results.push({ agent: agent.name, role: agent.role, output })
+    currentInput = output
+  }
+
+  return { pipeline: results, finalOutput: currentInput }
+}
+
+module.exports = { load, pipe }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "openrune",
-  "version": "0.1.2",
-  "description": "Rune — File-based AI Agent Desktop App",
-  "keywords": ["ai", "agent", "claude", "desktop", "electron", "mcp", "claude-code"],
+  "version": "0.2.0",
+  "description": "Rune — File-based AI Agent Harness for Claude Code",
+  "keywords": ["ai", "agent", "claude", "desktop", "electron", "mcp", "claude-code", "harness", "automation"],
   "repository": {
     "type": "git",
     "url": "https://github.com/gilhyun/Rune.git"
@@ -11,6 +11,9 @@
   "license": "MIT",
   "author": "gilhyun",
   "main": "bootstrap.js",
+  "exports": {
+    ".": "./lib/index.js"
+  },
   "bin": {
     "rune": "bin/rune.js"
   },