tissues 0.6.0 → 0.6.2

package/src/lib/ai/adapters/cli-adapters.test.js

@@ -0,0 +1,133 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { GeminiCliAdapter } from './gemini-cli.js'
+import { ClaudeCliAdapter } from './claude-cli.js'
+import { CodexCliAdapter } from './codex-cli.js'
+import { OpenClawAdapter } from './openclaw.js'
+
+describe('GeminiCliAdapter', () => {
+  it('has correct name', () => {
+    const adapter = new GeminiCliAdapter({ binary: 'gemini' })
+    assert.equal(adapter.name, 'gemini-cli')
+  })
+
+  it('isConfigured returns true when binary is set', () => {
+    const adapter = new GeminiCliAdapter({ binary: 'gemini' })
+    assert.equal(adapter.isConfigured(), true)
+  })
+
+  it('isConfigured returns false when binary is not set', () => {
+    const adapter = new GeminiCliAdapter({})
+    assert.equal(adapter.isConfigured(), false)
+  })
+
+  it('complete rejects when binary does not exist', async () => {
+    const adapter = new GeminiCliAdapter({ binary: 'nonexistent-gemini-binary-xyz' })
+    await assert.rejects(
+      () => adapter.complete([{ role: 'user', content: 'test' }]),
+      /gemini-cli error/,
+    )
+  })
+})
+
+describe('ClaudeCliAdapter', () => {
+  it('has correct name', () => {
+    const adapter = new ClaudeCliAdapter({ binary: 'claude' })
+    assert.equal(adapter.name, 'claude-cli')
+  })
+
+  it('isConfigured returns true when binary is set', () => {
+    const adapter = new ClaudeCliAdapter({ binary: 'claude' })
+    assert.equal(adapter.isConfigured(), true)
+  })
+
+  it('isConfigured returns false when binary is not set', () => {
+    const adapter = new ClaudeCliAdapter({})
+    assert.equal(adapter.isConfigured(), false)
+  })
+
+  it('complete rejects when binary does not exist', async () => {
+    const adapter = new ClaudeCliAdapter({ binary: 'nonexistent-claude-binary-xyz' })
+    await assert.rejects(
+      () => adapter.complete([{ role: 'user', content: 'test' }]),
+      /claude-cli error/,
+    )
+  })
+})
+
+describe('CodexCliAdapter', () => {
+  it('has correct name', () => {
+    const adapter = new CodexCliAdapter({ binary: 'codex' })
+    assert.equal(adapter.name, 'codex-cli')
+  })
+
+  it('isConfigured returns true when binary is set', () => {
+    const adapter = new CodexCliAdapter({ binary: 'codex' })
+    assert.equal(adapter.isConfigured(), true)
+  })
+
+  it('isConfigured returns false when binary is not set', () => {
+    const adapter = new CodexCliAdapter({})
+    assert.equal(adapter.isConfigured(), false)
+  })
+
+  it('complete rejects when binary does not exist', async () => {
+    const adapter = new CodexCliAdapter({ binary: 'nonexistent-codex-binary-xyz' })
+    await assert.rejects(
+      () => adapter.complete([{ role: 'user', content: 'test' }]),
+      /codex-cli error|git/,
+    )
+  })
+})
+
+describe('OpenClawAdapter', () => {
+  it('has correct name', () => {
+    const adapter = new OpenClawAdapter({ gatewayUrl: 'http://localhost:18790', token: 'test' })
+    assert.equal(adapter.name, 'openclaw')
+  })
+
+  it('isConfigured returns true with url and token', () => {
+    const adapter = new OpenClawAdapter({ gatewayUrl: 'http://localhost:18790', token: 'test' })
+    assert.equal(adapter.isConfigured(), true)
+  })
+
+  it('isConfigured returns false without token', () => {
+    const adapter = new OpenClawAdapter({ gatewayUrl: 'http://localhost:18790' })
+    assert.equal(adapter.isConfigured(), false)
+  })
+
+  it('isConfigured returns false without url', () => {
+    const adapter = new OpenClawAdapter({ token: 'test' })
+    assert.equal(adapter.isConfigured(), false)
+  })
+
+  it('healthCheck returns false for unreachable gateway', async () => {
+    const adapter = new OpenClawAdapter({ gatewayUrl: 'http://localhost:1', token: 'test' })
+    const healthy = await adapter.healthCheck()
+    assert.equal(healthy, false)
+  })
+
+  it('complete rejects without gateway url', async () => {
+    const adapter = new OpenClawAdapter({ token: 'test' })
+    await assert.rejects(
+      () => adapter.complete([{ role: 'user', content: 'test' }]),
+      /gateway URL not configured/,
+    )
+  })
+
+  it('complete rejects without token', async () => {
+    const adapter = new OpenClawAdapter({ gatewayUrl: 'http://localhost:18790' })
+    await assert.rejects(
+      () => adapter.complete([{ role: 'user', content: 'test' }]),
+      /token not configured/,
+    )
+  })
+
+  it('complete rejects when gateway is unreachable', async () => {
+    const adapter = new OpenClawAdapter({ gatewayUrl: 'http://localhost:1', token: 'test' })
+    await assert.rejects(
+      () => adapter.complete([{ role: 'user', content: 'test' }]),
+      /not reachable/,
+    )
+  })
+})

package/src/lib/ai/adapters/codex-cli.js

@@ -0,0 +1,77 @@
+import { execFile } from 'node:child_process'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { BaseAdapter } from './base.js'
+
+const DEFAULT_TIMEOUT_MS = 120_000
+
+/**
+ * Adapter for the OpenAI Codex CLI.
+ * Codex requires a git repo, so we create a temp dir with git init.
+ * Uses: codex exec 'prompt'
+ */
+export class CodexCliAdapter extends BaseAdapter {
+  get name() {
+    return 'codex-cli'
+  }
+
+  isConfigured() {
+    return !!this.config.binary
+  }
+
+  async complete(messages, opts = {}) {
+    const binary = this.config.binary || 'codex'
+    const timeoutMs = this.config.timeout || DEFAULT_TIMEOUT_MS
+
+    const lastUserMsg = [...messages].reverse().find((m) => m.role === 'user')
+    const promptText = lastUserMsg?.content || ''
+
+    const systemParts = messages.filter((m) => m.role === 'system').map((m) => m.content)
+    const fullPrompt = systemParts.length
+      ? `${systemParts.join('\n\n')}\n\n${promptText}`
+      : promptText
+
+    // Codex requires a git repository — create a temp one
+    const tempDir = mkdtempSync(join(tmpdir(), 'tissues-codex-'))
+
+    try {
+      // Initialize git repo in temp dir
+      await this._exec('git', ['init', '--quiet'], { cwd: tempDir, timeout: 10_000 })
+
+      const args = ['exec', fullPrompt]
+
+      return await new Promise((resolve, reject) => {
+        execFile(binary, args, {
+          cwd: tempDir,
+          timeout: timeoutMs,
+          maxBuffer: 10 * 1024 * 1024,
+        }, (err, stdout, stderr) => {
+          if (err) {
+            const msg = stderr?.trim() || err.message
+            reject(new Error(`codex-cli error: ${this.sanitizeErrorBody(msg)}`))
+            return
+          }
+          const text = stdout.trim()
+          if (!text) {
+            reject(new Error('codex-cli returned no output'))
+            return
+          }
+          resolve(text)
+        })
+      })
+    } finally {
+      try { rmSync(tempDir, { recursive: true, force: true }) } catch { /* cleanup best-effort */ }
+    }
+  }
+
+  /** @private */
+  _exec(cmd, args, opts) {
+    return new Promise((resolve, reject) => {
+      execFile(cmd, args, opts, (err, stdout) => {
+        if (err) reject(err)
+        else resolve(stdout)
+      })
+    })
+  }
+}

package/src/lib/ai/adapters/command.js

@@ -16,27 +16,35 @@ export class CommandAdapter extends BaseAdapter {
     const command = this.config.command
     if (!command) throw new Error('Command not configured (ai.command)')
 
-    const timeoutMs = opts.maxTokens
-      ? Math.max(DEFAULT_TIMEOUT_MS, opts.maxTokens * 15) // rough heuristic
-      : DEFAULT_TIMEOUT_MS
+    const timeoutMs = this.config.timeout
+      || (opts.maxTokens
+        ? Math.max(DEFAULT_TIMEOUT_MS, opts.maxTokens * 15) // rough heuristic
+        : DEFAULT_TIMEOUT_MS)
 
-    const payload = JSON.stringify({
+    // Extract the last user message as the prompt text
+    const lastUserMsg = [...messages].reverse().find((m) => m.role === 'user')
+    const promptText = lastUserMsg?.content || ''
+
+    // Check if command uses {prompt} placeholder (arg mode) or JSON stdin
+    const usesPlaceholder = command.includes('{prompt}')
+
+    const resolvedCommand = usesPlaceholder
+      ? command.replace(/\{prompt\}/g, promptText)
+      : command
+
+    const payload = usesPlaceholder ? null : JSON.stringify({
       messages: messages.map((m) => ({ role: m.role, content: m.content })),
       model: opts.model || null,
       maxTokens: opts.maxTokens || 4096,
     })
 
     return new Promise((resolve, reject) => {
-      // Split command string into executable + args
-      const parts = command.split(/\s+/)
-      const exe = parts[0]
-      const args = parts.slice(1)
-
-      const isWindows = process.platform === 'win32'
-      const child = execFile(exe, args, {
+      // Always use shell to support quoted args, pipes, builtins, etc.
+      const shell = process.platform === 'win32' ? true : '/bin/sh'
+      const child = execFile('sh', ['-c', resolvedCommand], {
         timeout: timeoutMs,
         maxBuffer: 10 * 1024 * 1024, // 10 MB
-        shell: isWindows,
+        shell: false, // we're already wrapping in sh -c
       }, (err, stdout, stderr) => {
         if (err) {
           const msg = stderr?.trim() || err.message
@@ -51,7 +59,9 @@ export class CommandAdapter extends BaseAdapter {
         resolve(text)
       })
 
-      child.stdin.write(payload)
+      if (payload) {
+        child.stdin.write(payload)
+      }
       child.stdin.end()
     })
   }

package/src/lib/ai/adapters/gemini-cli.js

@@ -0,0 +1,55 @@
+import { execFile } from 'node:child_process'
+import { BaseAdapter } from './base.js'
+
+const DEFAULT_TIMEOUT_MS = 120_000
+
+/**
+ * Adapter for the Gemini CLI (google-gemini/gemini-cli).
+ * Uses: gemini -p 'prompt' --model MODEL -s
+ */
+export class GeminiCliAdapter extends BaseAdapter {
+  get name() {
+    return 'gemini-cli'
+  }
+
+  isConfigured() {
+    return !!this.config.binary
+  }
+
+  async complete(messages, opts = {}) {
+    const binary = this.config.binary || 'gemini'
+    const model = opts.model || this.config.model || null
+    const timeoutMs = this.config.timeout || DEFAULT_TIMEOUT_MS
+
+    const lastUserMsg = [...messages].reverse().find((m) => m.role === 'user')
+    const promptText = lastUserMsg?.content || ''
+
+    // Build system context from system messages
+    const systemParts = messages.filter((m) => m.role === 'system').map((m) => m.content)
+    const fullPrompt = systemParts.length
+      ? `${systemParts.join('\n\n')}\n\n${promptText}`
+      : promptText
+
+    const args = ['-p', fullPrompt, '-s']
+    if (model) args.push('--model', model)
+
+    return new Promise((resolve, reject) => {
+      execFile(binary, args, {
+        timeout: timeoutMs,
+        maxBuffer: 10 * 1024 * 1024,
+      }, (err, stdout, stderr) => {
+        if (err) {
+          const msg = stderr?.trim() || err.message
+          reject(new Error(`gemini-cli error: ${this.sanitizeErrorBody(msg)}`))
+          return
+        }
+        const text = stdout.trim()
+        if (!text) {
+          reject(new Error('gemini-cli returned no output'))
+          return
+        }
+        resolve(text)
+      })
+    })
+  }
+}

package/src/lib/ai/adapters/openclaw.js

@@ -0,0 +1,91 @@
+import { BaseAdapter } from './base.js'
+
+const DEFAULT_TIMEOUT_MS = 120_000
+
+/**
+ * Adapter for OpenClaw gateway.
+ * Connects via HTTP API to the local (or remote) OpenClaw gateway.
+ */
+export class OpenClawAdapter extends BaseAdapter {
+  get name() {
+    return 'openclaw'
+  }
+
+  isConfigured() {
+    return !!this.config.gatewayUrl && !!this.config.token
+  }
+
+  /**
+   * Check if the OpenClaw gateway is healthy.
+   * @returns {Promise<boolean>}
+   */
+  async healthCheck() {
+    try {
+      const url = `${this.config.gatewayUrl}/api/v1/health`
+      const res = await fetch(url, {
+        method: 'GET',
+        headers: this._headers(),
+        signal: AbortSignal.timeout(5000),
+      })
+      return res.ok
+    } catch {
+      return false
+    }
+  }
+
+  async complete(messages, opts = {}) {
+    const gatewayUrl = this.config.gatewayUrl
+    if (!gatewayUrl) throw new Error('OpenClaw gateway URL not configured')
+    if (!this.config.token) throw new Error('OpenClaw gateway token not configured')
+
+    // Check gateway health before making the request
+    const healthy = await this.healthCheck()
+    if (!healthy) {
+      throw new Error(`OpenClaw gateway not reachable at ${gatewayUrl}`)
+    }
+
+    const timeoutMs = this.config.timeout || DEFAULT_TIMEOUT_MS
+    const agentId = this.config.agentId || null
+
+    const body = {
+      messages: messages.map((m) => ({ role: m.role, content: m.content })),
+      model: opts.model || this.config.model || null,
+      max_tokens: opts.maxTokens || 4096,
+    }
+    if (agentId) body.agent_id = agentId
+
+    const url = `${gatewayUrl}/api/v1/inference`
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        ...this._headers(),
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(timeoutMs),
+    })
+
+    if (!res.ok) {
+      const errText = await res.text().catch(() => '')
+      throw new Error(`OpenClaw error (${res.status}): ${this.sanitizeErrorBody(errText)}`)
+    }
+
+    const data = await res.json()
+
+    // Support both { text } and { choices[0].message.content } response shapes
+    const text = data.text
+      || data.choices?.[0]?.message?.content
+      || data.content
+      || ''
+
+    if (!text) throw new Error('OpenClaw returned no output')
+    return text.trim()
+  }
+
+  /** @private */
+  _headers() {
+    return {
+      Authorization: `Bearer ${this.config.token}`,
+    }
+  }
+}

package/src/lib/ai/agent-actions.js

@@ -0,0 +1,271 @@
+/**
+ * Action handlers for the AI agent.
+ *
+ * Each handler wraps an existing library function and returns a
+ * result object suitable for feeding back into the conversation.
+ */
+
+import { store } from '../config.js'
+import { loadConfig, getConfigValue, findRepoRoot } from '../defaults.js'
+import { ensureFresh, getCachedIssues, getCachedLabels, upsertCachedIssue } from '../cache.js'
+import { readDrafts } from '../drafts.js'
+import { listTemplates } from '../templates.js'
+import { listEnhancements } from '../enhancements.js'
+import { runCreate } from '../../commands/create.js'
+import { checkSafety, getSafetyStatus } from '../safety.js'
+import { bold, dim, cyan, green, yellow, red } from '../color.js'
+
+// ---------------------------------------------------------------------------
+// Action registry
+// ---------------------------------------------------------------------------
+
+/**
+ * Action schema definitions for the AI system prompt.
+ * Each entry: { name, description, params, requiresConfirmation }
+ */
+export const ACTION_SCHEMAS = [
+  {
+    name: 'create_issue',
+    description: 'Create a new GitHub issue',
+    params: { title: 'string (required)', body: 'string', labels: 'string (comma-separated)', template: 'string', repo: 'string' },
+    requiresConfirmation: true,
+  },
+  {
+    name: 'list_issues',
+    description: 'List issues from the local cache',
+    params: { repo: 'string', state: '"open" | "closed"', limit: 'number' },
+    requiresConfirmation: false,
+  },
+  {
+    name: 'list_labels',
+    description: 'List labels for a repo',
+    params: { repo: 'string' },
+    requiresConfirmation: false,
+  },
+  {
+    name: 'list_drafts',
+    description: 'List pending issue drafts',
+    params: {},
+    requiresConfirmation: false,
+  },
+  {
+    name: 'show_config',
+    description: 'Show a config value',
+    params: { key: 'string (dot-notation, e.g. "ai.provider")' },
+    requiresConfirmation: false,
+  },
+  {
+    name: 'set_config',
+    description: 'Set a runtime config value',
+    params: { key: 'string', value: 'any' },
+    requiresConfirmation: true,
+  },
+  {
+    name: 'switch_repo',
+    description: 'Switch the active repository',
+    params: { repo: 'string (owner/name)' },
+    requiresConfirmation: true,
+  },
+  {
+    name: 'list_templates',
+    description: 'List available issue templates',
+    params: {},
+    requiresConfirmation: false,
+  },
+  {
+    name: 'list_enhancements',
+    description: 'List available AI enhancements',
+    params: {},
+    requiresConfirmation: false,
+  },
+  {
+    name: 'show_status',
+    description: 'Show safety status (circuit breaker, rate limits)',
+    params: { repo: 'string' },
+    requiresConfirmation: false,
+  },
+  {
+    name: 'answer',
+    description: 'Respond to the user with text (use when no action is needed)',
+    params: { text: 'string' },
+    requiresConfirmation: false,
+  },
+]
+
+// ---------------------------------------------------------------------------
+// Action handlers
+// ---------------------------------------------------------------------------
+
+/**
+ * Execute an action by name with the given params.
+ *
+ * @param {string} actionName
+ * @param {object} params
+ * @param {{ activeRepo: string, config: object, repoRoot: string }} context
+ * @returns {Promise<{ success: boolean, result: any, display?: string }>}
+ */
+export async function executeAction(actionName, params, context) {
+  const handler = handlers[actionName]
+  if (!handler) {
+    return { success: false, result: `Unknown action: ${actionName}` }
+  }
+  try {
+    return await handler(params, context)
+  } catch (err) {
+    return { success: false, result: err.message }
+  }
+}
+
+const handlers = {
+  async create_issue(params, context) {
+    const repo = params.repo || context.activeRepo
+    if (!repo) return { success: false, result: 'No repo specified and no active repo set.' }
+
+    const result = await runCreate({
+      repo,
+      title: params.title,
+      body: params.body || undefined,
+      labels: params.labels || undefined,
+      template: params.template || undefined,
+      enhance: true,
+    })
+
+    if (result) {
+      return {
+        success: true,
+        result: { number: result.number, url: result.url },
+        display: `${green('Issue created:')} ${cyan(result.url)}`,
+      }
+    }
+    return { success: true, result: 'Issue creation completed (dry-run or draft mode).' }
+  },
+
+  async list_issues(params, context) {
+    const repo = params.repo || context.activeRepo
+    if (!repo) return { success: false, result: 'No repo specified.' }
+
+    const state = params.state || 'open'
+    const limit = params.limit || 20
+    const issues = ensureFresh(repo, 'issues', { state, limit, acceptStale: true })
+    const display = issues.length === 0
+      ? dim('No issues found.')
+      : issues.map(i => `  #${i.number}  ${i.title}${i.labels?.length ? '  ' + dim(i.labels.join(', ')) : ''}`).join('\n')
+
+    return {
+      success: true,
+      result: issues.map(i => ({ number: i.number, title: i.title, labels: i.labels, state: i.state })),
+      display: `${bold(`${state} issues in ${repo}`)} (${issues.length})\n${display}`,
+    }
+  },
+
+  async list_labels(params, context) {
+    const repo = params.repo || context.activeRepo
+    if (!repo) return { success: false, result: 'No repo specified.' }
+
+    const labels = ensureFresh(repo, 'labels', { acceptStale: true })
+    return {
+      success: true,
+      result: labels,
+      display: labels.length === 0
+        ? dim('No labels.')
+        : `${bold(`Labels in ${repo}`)} (${labels.length})\n  ${labels.join(', ')}`,
+    }
+  },
+
+  async list_drafts(_params, context) {
+    const drafts = readDrafts(context.repoRoot)
+    const pending = drafts.filter(d => d.status === 'draft' || d.status === 'pending')
+    return {
+      success: true,
+      result: pending.map(d => ({ id: d.id, title: d.title, status: d.status, repo: d.repo })),
+      display: pending.length === 0
+        ? dim('No pending drafts.')
+        : pending.map(d => `  ${d.status === 'pending' ? yellow('pending') : dim('draft')}  ${d.title}`).join('\n'),
+    }
+  },
+
+  async show_config(params, _context) {
+    const key = params.key
+    if (!key) return { success: false, result: 'No config key specified.' }
+    const value = getConfigValue(key)
+    return {
+      success: true,
+      result: value,
+      display: `${dim(key + ':')} ${typeof value === 'object' ? JSON.stringify(value, null, 2) : String(value)}`,
+    }
+  },
+
+  async set_config(params, _context) {
+    const { key, value } = params
+    if (!key) return { success: false, result: 'No config key specified.' }
+    store.set(key, value)
+    return {
+      success: true,
+      result: { key, value },
+      display: `${green('Set')} ${key} = ${JSON.stringify(value)}`,
+    }
+  },
+
+  async switch_repo(params, _context) {
+    const { repo } = params
+    if (!repo) return { success: false, result: 'No repo specified.' }
+    store.set('activeRepo', repo)
+    return {
+      success: true,
+      result: { activeRepo: repo },
+      display: `${green('Switched to')} ${cyan(repo)}`,
+    }
+  },
+
+  async list_templates(_params, context) {
+    const templates = listTemplates(context.repoRoot)
+    const seen = new Set()
+    const unique = templates.filter(t => {
+      if (seen.has(t.key)) return false
+      seen.add(t.key)
+      return true
+    })
+    return {
+      success: true,
+      result: unique.map(t => ({ key: t.key, name: t.name, source: t.source })),
+      display: unique.map(t => `  ${t.key} ${dim(`(${t.source})`)}`).join('\n'),
+    }
+  },
+
+  async list_enhancements(_params, context) {
+    const enhancements = listEnhancements(context.repoRoot)
+    const seen = new Set()
+    const unique = enhancements.filter(e => {
+      if (seen.has(e.key)) return false
+      seen.add(e.key)
+      return true
+    })
+    return {
+      success: true,
+      result: unique.map(e => ({ key: e.key, name: e.name, mode: e.mode, source: e.source })),
+      display: unique.map(e => `  ${e.key} ${dim(e.mode)} ${dim(`(${e.source})`)}`).join('\n'),
+    }
+  },
+
+  async show_status(params, context) {
+    const repo = params.repo || context.activeRepo
+    if (!repo) return { success: false, result: 'No repo specified.' }
+
+    const config = context.config
+    const agent = config.attribution?.defaultAgent || 'human'
+    const status = getSafetyStatus(repo, agent, config.safety)
+    return {
+      success: true,
+      result: status,
+      display: status,
+    }
+  },
+
+  async answer(params, _context) {
+    return {
+      success: true,
+      result: params.text || '',
+      display: params.text || '',
+    }
+  },
+}