tissues 0.6.1 → 0.6.2

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 || '',
+    }
+  },
+}