tissues 0.6.1 → 0.6.2

package/src/commands/sync.js

@@ -0,0 +1,225 @@
+/**
+ * Sync command — manual one-shot sync + background daemon management.
+ */
+
+import { Command } from 'commander'
+import { fork } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { fileURLToPath } from 'node:url'
+import { store } from '../lib/config.js'
+import { requireAuth } from '../lib/gh.js'
+import { syncIssues, syncLabels, syncRepos } from '../lib/cache.js'
+import { pickRepo } from '../lib/repo-picker.js'
+import { green, yellow, red, dim, cyan, bold } from '../lib/color.js'
+import ora from 'ora'
+
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'tissues')
+const PID_FILE = path.join(CONFIG_DIR, 'sync.pid')
+const STATUS_FILE = path.join(CONFIG_DIR, 'sync-status.json')
+
+// ---------------------------------------------------------------------------
+// Daemon helpers
+// ---------------------------------------------------------------------------
+
+function readPid() {
+  try {
+    const pid = parseInt(fs.readFileSync(PID_FILE, 'utf8').trim(), 10)
+    // Check if process is alive
+    process.kill(pid, 0)
+    return pid
+  } catch {
+    // Clean up stale PID file
+    try { fs.unlinkSync(PID_FILE) } catch { /* ok */ }
+    return null
+  }
+}
+
+function readStatus() {
+  try {
+    return JSON.parse(fs.readFileSync(STATUS_FILE, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+function recordActivity() {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true })
+  const status = readStatus() || {}
+  status.lastActivity = new Date().toISOString()
+  fs.writeFileSync(STATUS_FILE, JSON.stringify(status, null, 2), 'utf8')
+}
+
+// ---------------------------------------------------------------------------
+// Main sync command (one-shot)
+// ---------------------------------------------------------------------------
+
+export const syncCommand = new Command('sync')
+  .description('Sync issues, labels, and repos to local cache')
+  .option('--repo <repo>', 'Repository to sync (default: active repo)')
+  .option('--force', 'Force full sync, ignore freshness')
+  .option('--quiet', 'Suppress output')
+  .action(async (opts) => {
+    requireAuth()
+
+    let repo = opts.repo || store.get('activeRepo')
+    if (!repo) {
+      console.log(yellow('No active repo. Pick one:\n'))
+      repo = await pickRepo()
+      console.log()
+    }
+
+    const log = opts.quiet ? () => {} : console.log
+
+    // Sync repos
+    const repoSpinner = opts.quiet ? null : ora('Syncing repos...').start()
+    try {
+      const result = syncRepos({ force: opts.force })
+      if (repoSpinner) repoSpinner.succeed(`Repos: ${result.synced} cached`)
+    } catch (err) {
+      if (repoSpinner) repoSpinner.warn(`Repos sync failed: ${err.message}`)
+    }
+
+    // Sync labels
+    const labelSpinner = opts.quiet ? null : ora('Syncing labels...').start()
+    try {
+      const result = syncLabels(repo, { force: opts.force })
+      if (labelSpinner) labelSpinner.succeed(`Labels: ${result.synced} cached`)
+    } catch (err) {
+      if (labelSpinner) labelSpinner.warn(`Labels sync failed: ${err.message}`)
+    }
+
+    // Sync issues (incremental)
+    const issueSpinner = opts.quiet ? null : ora('Syncing issues...').start()
+    try {
+      const result = syncIssues(repo, { force: opts.force })
+      if (issueSpinner) issueSpinner.succeed(`Issues: ${result.synced} synced (${result.total} total)`)
+    } catch (err) {
+      if (issueSpinner) issueSpinner.warn(`Issues sync failed: ${err.message}`)
+    }
+
+    log()
+    log(green('Sync complete.'))
+  })
+
+// ---------------------------------------------------------------------------
+// Daemon subcommands
+// ---------------------------------------------------------------------------
+
+const startCommand = new Command('start')
+  .description('Start the background sync daemon')
+  .action(() => {
+    const existing = readPid()
+    if (existing) {
+      console.log(yellow(`Daemon already running (PID ${existing}).`))
+      return
+    }
+
+    const __dirname = path.dirname(fileURLToPath(import.meta.url))
+    const daemonScript = path.join(__dirname, '..', 'daemon', 'sync.js')
+
+    const child = fork(daemonScript, [], {
+      detached: true,
+      stdio: 'ignore',
+    })
+    child.unref()
+
+    console.log(green(`Sync daemon started (PID ${child.pid}).`))
+    console.log(dim('Run `tissues sync status` to check on it.'))
+  })
+
+const stopCommand = new Command('stop')
+  .description('Stop the background sync daemon')
+  .action(() => {
+    const pid = readPid()
+    if (!pid) {
+      console.log(dim('No daemon running.'))
+      return
+    }
+
+    try {
+      process.kill(pid, 'SIGTERM')
+      console.log(green(`Daemon stopped (PID ${pid}).`))
+    } catch (err) {
+      console.warn(yellow(`Could not stop daemon: ${err.message}`))
+      // Clean up stale PID file
+      try { fs.unlinkSync(PID_FILE) } catch { /* ok */ }
+    }
+  })
+
+const restartCommand = new Command('restart')
+  .description('Restart the background sync daemon')
+  .action(async () => {
+    // Stop
+    const pid = readPid()
+    if (pid) {
+      try {
+        process.kill(pid, 'SIGTERM')
+        console.log(dim(`Stopped daemon (PID ${pid}).`))
+        // Brief wait for cleanup
+        await new Promise(r => setTimeout(r, 500))
+      } catch { /* ok */ }
+    }
+
+    // Start
+    const __dirname = path.dirname(fileURLToPath(import.meta.url))
+    const daemonScript = path.join(__dirname, '..', 'daemon', 'sync.js')
+
+    const child = fork(daemonScript, [], {
+      detached: true,
+      stdio: 'ignore',
+    })
+    child.unref()
+
+    console.log(green(`Sync daemon restarted (PID ${child.pid}).`))
+  })
+
+const statusCommand = new Command('status')
+  .description('Show background sync daemon status')
+  .action(() => {
+    const pid = readPid()
+    const status = readStatus()
+
+    if (!pid && !status) {
+      console.log(dim('No daemon has been started.'))
+      console.log(dim('Run `tissues sync start` to begin background syncing.'))
+      return
+    }
+
+    console.log(bold('\nSync Daemon'))
+    if (pid) {
+      console.log(`  Status:     ${green('running')} (PID ${pid})`)
+    } else {
+      console.log(`  Status:     ${dim(status?.status || 'stopped')}`)
+    }
+
+    if (status) {
+      if (status.startedAt) console.log(`  Started:    ${dim(status.startedAt)}`)
+      if (status.lastSync) console.log(`  Last sync:  ${dim(status.lastSync)}`)
+      if (status.nextSync) console.log(`  Next sync:  ${dim(status.nextSync)}`)
+      if (status.lastError) console.log(`  Last error: ${red(status.lastError)}`)
+
+      if (status.perRepoStats) {
+        console.log(bold('\n  Per-repo stats:'))
+        for (const [repo, stats] of Object.entries(status.perRepoStats)) {
+          if (stats.status === 'ok') {
+            console.log(`    ${cyan(repo)}: ${stats.issues} issues, ${stats.labels} labels`)
+          } else if (stats.status === 'error') {
+            console.log(`    ${cyan(repo)}: ${red(stats.error)}`)
+          } else if (stats.status === 'skipped') {
+            console.log(`    ${cyan(repo)}: ${yellow(stats.reason)}`)
+          }
+        }
+      }
+    }
+    console.log()
+  })
+
+syncCommand.addCommand(startCommand)
+syncCommand.addCommand(stopCommand)
+syncCommand.addCommand(restartCommand)
+syncCommand.addCommand(statusCommand)
+
+// Export recordActivity for use in preAction hook
+export { recordActivity }

package/src/daemon/sync.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+
+/**
+ * Background sync daemon for tissues.
+ *
+ * Keeps the local cache warm by periodically syncing issues, labels,
+ * and repos in the background. Runs as a detached child process.
+ *
+ * PID file: ~/.config/tissues/sync.pid
+ * Status file: ~/.config/tissues/sync-status.json
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import { syncIssues, syncLabels, syncRepos } from '../lib/cache.js'
+import { getToken } from '../lib/gh.js'
+import { loadConfig } from '../lib/defaults.js'
+import { store } from '../lib/config.js'
+
+// ---------------------------------------------------------------------------
+// Paths
+// ---------------------------------------------------------------------------
+
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'tissues')
+const PID_FILE = path.join(CONFIG_DIR, 'sync.pid')
+const STATUS_FILE = path.join(CONFIG_DIR, 'sync-status.json')
+
+// ---------------------------------------------------------------------------
+// Status file operations
+// ---------------------------------------------------------------------------
+
+function readStatus() {
+  try {
+    return JSON.parse(fs.readFileSync(STATUS_FILE, 'utf8'))
+  } catch {
+    return {}
+  }
+}
+
+function writeStatus(updates) {
+  const current = readStatus()
+  const merged = { ...current, ...updates }
+  fs.mkdirSync(CONFIG_DIR, { recursive: true })
+  fs.writeFileSync(STATUS_FILE, JSON.stringify(merged, null, 2), 'utf8')
+}
+
+// ---------------------------------------------------------------------------
+// Adaptive interval
+// ---------------------------------------------------------------------------
+
+function getInterval(config) {
+  const syncConfig = config.sync || {}
+  const baseInterval = (syncConfig.interval || 300) * 1000
+
+  if (!syncConfig.adaptiveInterval) return baseInterval
+
+  const status = readStatus()
+  const lastActivity = status.lastActivity ? new Date(status.lastActivity).getTime() : 0
+  const idle = Date.now() - lastActivity
+
+  const THIRTY_MIN = 30 * 60 * 1000
+  const TWO_HOURS = 2 * 60 * 60 * 1000
+  const EIGHT_HOURS = 8 * 60 * 60 * 1000
+
+  if (idle < THIRTY_MIN) return 2 * 60 * 1000   // Active: every 2 min
+  if (idle < TWO_HOURS) return 5 * 60 * 1000     // Normal: every 5 min
+  if (idle < EIGHT_HOURS) return 15 * 60 * 1000  // Idle: every 15 min
+  return 60 * 60 * 1000                           // Sleep: every 60 min
+}
+
+// ---------------------------------------------------------------------------
+// Sync cycle
+// ---------------------------------------------------------------------------
+
+const failureCounts = new Map()  // repo -> consecutive failure count
+const SKIP_THRESHOLD = 5
+const SKIP_DURATION = 60 * 60 * 1000  // 1 hour
+const skipUntil = new Map()
+
+async function syncCycle(config) {
+  // Auth check
+  const token = getToken()
+  if (!token) {
+    writeStatus({ lastError: 'Not authenticated', lastErrorAt: new Date().toISOString() })
+    return
+  }
+
+  const syncConfig = config.sync || {}
+  const repos = syncConfig.repos?.length
+    ? syncConfig.repos
+    : [store.get('activeRepo')].filter(Boolean)
+
+  if (repos.length === 0) {
+    writeStatus({ lastError: 'No repos configured', lastErrorAt: new Date().toISOString() })
+    return
+  }
+
+  const perRepoStats = {}
+
+  for (const repo of repos) {
+    // Check skip
+    const skipTime = skipUntil.get(repo)
+    if (skipTime && Date.now() < skipTime) {
+      perRepoStats[repo] = { status: 'skipped', reason: 'too many failures' }
+      continue
+    }
+
+    try {
+      const issueResult = syncIssues(repo)
+      const labelResult = syncLabels(repo)
+      perRepoStats[repo] = {
+        status: 'ok',
+        issues: issueResult.synced,
+        labels: labelResult.synced,
+      }
+      failureCounts.set(repo, 0)
+    } catch (err) {
+      const count = (failureCounts.get(repo) || 0) + 1
+      failureCounts.set(repo, count)
+      perRepoStats[repo] = { status: 'error', error: err.message }
+
+      if (count >= SKIP_THRESHOLD) {
+        skipUntil.set(repo, Date.now() + SKIP_DURATION)
+        perRepoStats[repo].skippedUntil = new Date(Date.now() + SKIP_DURATION).toISOString()
+      }
+    }
+  }
+
+  // Sync repos list (global, not per-repo)
+  try {
+    syncRepos()
+  } catch {
+    // Non-fatal
+  }
+
+  writeStatus({
+    lastSync: new Date().toISOString(),
+    perRepoStats,
+    lastError: null,
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Main loop
+// ---------------------------------------------------------------------------
+
+async function main() {
+  // Write PID
+  fs.mkdirSync(CONFIG_DIR, { recursive: true })
+  fs.writeFileSync(PID_FILE, String(process.pid), 'utf8')
+
+  writeStatus({
+    pid: process.pid,
+    startedAt: new Date().toISOString(),
+    status: 'running',
+  })
+
+  // Graceful shutdown
+  const cleanup = () => {
+    writeStatus({ status: 'stopped', stoppedAt: new Date().toISOString() })
+    try { fs.unlinkSync(PID_FILE) } catch { /* ok */ }
+    process.exit(0)
+  }
+  process.on('SIGTERM', cleanup)
+  process.on('SIGINT', cleanup)
+
+  // Run first cycle immediately
+  const config = loadConfig()
+  await syncCycle(config)
+
+  // Schedule recurring
+  const schedule = () => {
+    const freshConfig = loadConfig()
+    const interval = getInterval(freshConfig)
+    writeStatus({ nextSync: new Date(Date.now() + interval).toISOString() })
+    setTimeout(async () => {
+      await syncCycle(freshConfig)
+      schedule()
+    }, interval)
+  }
+  schedule()
+}
+
+main().catch(err => {
+  writeStatus({ status: 'crashed', error: err.message, crashedAt: new Date().toISOString() })
+  try { fs.unlinkSync(PID_FILE) } catch { /* ok */ }
+  process.exit(1)
+})

package/src/lib/ai/adapters/claude-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 Claude Code CLI (anthropic claude-code).
+ * Uses: claude --print 'prompt' --model MODEL --dangerously-skip-permissions
+ */
+export class ClaudeCliAdapter extends BaseAdapter {
+  get name() {
+    return 'claude-cli'
+  }
+
+  isConfigured() {
+    return !!this.config.binary
+  }
+
+  async complete(messages, opts = {}) {
+    const binary = this.config.binary || 'claude'
+    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 = ['--print', fullPrompt, '--dangerously-skip-permissions']
+    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(`claude-cli error: ${this.sanitizeErrorBody(msg)}`))
+          return
+        }
+        const text = stdout.trim()
+        if (!text) {
+          reject(new Error('claude-cli returned no output'))
+          return
+        }
+        resolve(text)
+      })
+    })
+  }
+}

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)
+      })
+    })
+  }
+}