tissues 0.6.0 → 0.6.2

package/README.md

@@ -122,9 +122,64 @@ Manage issue templates interactively. View, edit, or create templates. Editing a
 tissues templates
 ```
 
+### `tissues ai`
+
+AI-powered issue management. The agent translates natural language into JSON actions with built-in guardrails — it only handles tissues/GitHub operations and declines off-topic requests.
+
+```bash
+# Single-shot: natural language → action
+tissues ai list my open issues
+tissues ai what repos do I have access to
+tissues ai create a bug report about login failing on Safari
+
+# Preview without executing
+tissues ai --dry-run add a feature request for dark mode
+
+# Multi-turn conversation
+tissues ai --chat
+tissues ai --chat "set up labels for our project"
+```
+
+In chat mode, the agent can list issues, switch repos, manage config, create issues, and more — all from natural language. Test the agent with `npm run test:agent -- --mock`.
+
+> See [AI Agent docs](docs/features/ai.md#ai-agent-tissues-ai) for prompt architecture, guardrails, and testing details.
+
+### `tissues sync`
+
+Sync issues, labels, and repos to the local cache. The cache makes dedup checks instant and eliminates redundant network calls.
+
+```bash
+# One-shot sync
+tissues sync
+tissues sync --repo owner/other-repo
+tissues sync --force                    # full re-sync
+
+# Background daemon
+tissues sync start                      # fork daemon process
+tissues sync status                     # check daemon health
+tissues sync stop                       # stop daemon
+tissues sync restart
+```
+
+The daemon uses adaptive intervals (2 min when active, up to 60 min when idle) and incremental `since`-based fetching for issues.
+
+### `tissues storage`
+
+Inspect and manage all cached/stored data.
+
+```bash
+tissues storage                         # overview dashboard
+tissues storage issues                  # per-repo issue breakdown
+tissues storage clear issues            # clear cached issues
+tissues storage clear all               # clear everything
+tissues storage clear all --include-safety  # also reset circuit breaker
+tissues storage export                  # JSON dump for debugging
+tissues storage --json                  # machine-readable overview
+```
+
 ### `tissues list`
 
-Browse open issues for the active repo.
+Browse open issues for the active repo (served from local cache when fresh).
 
 ```bash
 tissues list
@@ -277,6 +332,22 @@ Configuration is loaded and merged from three sources in ascending priority orde
 }
 ```
 
+Background sync configuration (opt-in):
+
+```json
+{
+  "sync": {
+    "enabled": true,
+    "repos": [],
+    "interval": 300,
+    "adaptiveInterval": true,
+    "issueLimit": 500,
+    "includeClosedDays": 30,
+    "autoStart": false
+  }
+}
+```
+
 AI keys go in user-level config only (`~/.config/tissues/config.json`) — never commit them:
 
 ```json
@@ -414,6 +485,12 @@ tissues stores local state in a SQLite database at:
 - `rate_events` — timestamped creation events (for rate limiting)
 - `circuit_breaker` — circuit state per repo+agent (status, failure count, cooldown)
 - `idempotency_keys` — deterministic keys for agent-driven idempotency
+- `cached_issues` — locally cached GitHub issues for instant dedup and offline context
+- `cached_labels` — locally cached repo labels
+- `cached_repos` — locally cached repo list
+- `sync_meta` — sync cursors and timestamps for incremental fetching
+
+The cache tables are populated by `tissues sync` (manual or background daemon) and used transparently by `create`, `list`, `ai`, and dedup checks. Run `tissues storage` to inspect cache state.
 
 The database file can be committed to share dedup history across a team, or added to `.gitignore` to keep it local. It is created automatically on first use.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tissues",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "AI-enhanced GitHub issue creation with built-in safety guardrails. Wraps gh CLI with circuit breakers, rate limiting, dedup, and templates.",
   "type": "module",
   "bin": {
@@ -12,8 +12,10 @@
     "test": "node --experimental-test-module-mocks --test 'src/**/*.test.js'",
     "audit": "node scripts/audit.js",
     "build": "node scripts/build.js",
+    "prepublishOnly": "node scripts/audit.js",
     "dev:install": "node scripts/dev-install.js",
-    "dev:uninstall": "node scripts/dev-install.js --uninstall"
+    "dev:uninstall": "node scripts/dev-install.js --uninstall",
+    "test:agent": "node scripts/test-agent.js"
   },
   "keywords": [
     "git",

package/src/cli.js

@@ -7,8 +7,12 @@ import { createCommand, draftCommand } from './commands/create.js'
 import { listCommand } from './commands/list.js'
 import { statusCommand } from './commands/status.js'
 import { templatesCommand } from './commands/templates.js'
+import { enhancementsCommand } from './commands/enhancements.js'
 import { draftsCommand } from './commands/drafts.js'
 import { aiCommand } from './commands/ai.js'
+import { syncCommand, recordActivity } from './commands/sync.js'
+import { storageCommand } from './commands/storage.js'
+import { providersCommand } from './commands/providers.js'
 import { store } from './lib/config.js'
 import { requireGh } from './lib/gh.js'
 import { dim } from './lib/color.js'
@@ -21,7 +25,7 @@ function authDescription() {
 
 const SKIP_REPO_BANNER = new Set([
   'auth', 'login', 'status', 'switch', 'logout',
-  'config', 'drafts', 'publish', 'templates', 'ai',
+  'config', 'drafts', 'publish', 'templates', 'enhancements', 'ai', 'sync', 'storage', 'providers',
 ])
 
 program
@@ -41,6 +45,9 @@ program
     // Ensure gh is installed before any command
     requireGh()
 
+    // Record activity timestamp for adaptive sync interval
+    try { recordActivity() } catch { /* non-fatal */ }
+
     // Show active repo context on relevant commands only
     const parentName = actionCommand.parent?.name?.()
     if (!SKIP_REPO_BANNER.has(name) && !SKIP_REPO_BANNER.has(parentName)) {
@@ -67,5 +74,9 @@ program.addCommand(draftCommand)
 program.addCommand(listCommand)
 program.addCommand(statusCommand)
 program.addCommand(templatesCommand)
+program.addCommand(enhancementsCommand)
 program.addCommand(draftsCommand)
 program.addCommand(aiCommand)
+program.addCommand(syncCommand)
+program.addCommand(storageCommand)
+program.addCommand(providersCommand)

package/src/commands/ai.js

@@ -1,64 +1,28 @@
+/**
+ * AI command — general-purpose CLI operator with local context.
+ *
+ * Single-shot mode: backward-compatible NL → create_issue translation.
+ * Chat mode: multi-turn conversation for any tissues operation.
+ */
+
 import { Command } from 'commander'
-import { confirm } from '@inquirer/prompts'
+import { input, confirm } from '@inquirer/prompts'
 import { store } from '../lib/config.js'
 import { theme } from '../lib/theme.js'
 import { loadConfig, findRepoRoot } from '../lib/defaults.js'
-import { requireAuth, getAuthenticatedUser, listLabels, listRepos } from '../lib/gh.js'
-import { listTemplates } from '../lib/templates.js'
+import { requireAuth, getAuthenticatedUser } from '../lib/gh.js'
+import { ensureFresh } from '../lib/cache.js'
 import { checkDuplicate } from '../lib/dedup.js'
 import { resolveRoute } from '../lib/ai/router.js'
 import { checkAvailable } from '../lib/ai/index.js'
+import { runAgentSingleShot, runAgentLoop, parseAgentResponse } from '../lib/ai/agent.js'
+import { ACTION_SCHEMAS, executeAction } from '../lib/ai/agent-actions.js'
 import { runCreate } from './create.js'
 import { red, yellow, dim, bold, cyan } from '../lib/color.js'
 import ora from 'ora'
 
 // ---------------------------------------------------------------------------
-// System prompt — tells the AI how to build a `tissues create` invocation
-// ---------------------------------------------------------------------------
-
-function buildSystemPrompt(context) {
-  const lines = [
-    'You translate natural language into a `tissues create` command.',
-    'Return ONLY a JSON object with the fields to pass to the create command.',
-    '',
-    'Available fields:',
-    '  "title"    (required) — concise issue title',
-    '  "body"     (optional) — issue body in markdown',
-    '  "labels"   (optional) — comma-separated label names',
-    '  "template" (optional) — template key to use',
-    '  "repo"     (optional) — "owner/name", omit to use the active repo',
-    '',
-    'Rules:',
-    '- Return ONLY valid JSON. No markdown fences, no explanation.',
-    '- Write a clear, actionable title.',
-    '- If the user gives enough detail, write a well-structured markdown body.',
-    '- Only include fields the user mentions or that you can clearly infer.',
-    '- Pick labels from the available labels when appropriate.',
-    '- Pick a template that fits the issue type (bug, feature, default).',
-  ]
-
-  if (context.activeRepo) {
-    lines.push(`\nActive repo: ${context.activeRepo}`)
-  }
-  if (context.user) {
-    lines.push(`Authenticated user: ${context.user}`)
-  }
-  if (context.repos?.length) {
-    lines.push(`Available repos: ${context.repos.join(', ')}`)
-  }
-  if (context.templates?.length) {
-    const keys = [...new Set(context.templates.map((t) => t.key))]
-    lines.push(`Available templates: ${keys.join(', ')}`)
-  }
-  if (context.labels?.length) {
-    lines.push(`Labels on active repo: ${context.labels.join(', ')}`)
-  }
-
-  return lines.join('\n')
-}
-
-// ---------------------------------------------------------------------------
-// Gather context for the AI prompt
+// Gather context from cache (zero network calls if warm)
 // ---------------------------------------------------------------------------
 
 function gatherContext(opts) {
@@ -69,150 +33,163 @@ function gatherContext(opts) {
   const context = { activeRepo, config, repoRoot }
 
   try { context.user = getAuthenticatedUser() } catch { /* non-fatal */ }
-  try { context.templates = listTemplates(repoRoot) } catch { /* non-fatal */ }
-  try { context.repos = listRepos({ limit: 30 }) } catch { /* non-fatal */ }
-
-  if (activeRepo) {
-    try { context.labels = listLabels(activeRepo) } catch { /* non-fatal */ }
-  }
 
   return context
 }
 
-// ---------------------------------------------------------------------------
-// Parse AI response into runCreate opts
-// ---------------------------------------------------------------------------
-
-function parseCreateOpts(raw) {
-  let cleaned = raw.trim()
-  if (cleaned.startsWith('```')) {
-    cleaned = cleaned.replace(/^```(?:json)?\s*\n?/, '').replace(/\n?```\s*$/, '')
-  }
-
-  const parsed = JSON.parse(cleaned)
-  if (!parsed.title) throw new Error('AI response missing "title"')
-  return parsed
-}
-
 // ---------------------------------------------------------------------------
 // Command
 // ---------------------------------------------------------------------------
 
 export const aiCommand = new Command('ai')
-  .description('Create an issue from a natural language prompt')
-  .argument('[prompt...]', 'Describe the issue you want to create')
-  .option('--dry-run', 'Preview the create command without executing')
-  .option('--yes, -y', 'Skip confirmation, run create immediately')
+  .description('AI-powered issue management (single-shot or chat)')
+  .argument('[prompt...]', 'Describe what you want to do')
+  .option('--chat', 'Start a multi-turn conversation')
+  .option('--dry-run', 'Preview actions without executing')
+  .option('--yes, -y', 'Skip confirmation, run action immediately')
   .option('--repo <repo>', 'Override active repo')
+  .option('--enhancements <names>', 'Comma-separated enhancement names to run')
   .option('--provider <name>', 'AI provider override')
   .option('--model <name>', 'AI model override')
   .action(async (promptWords, opts) => {
-    if (!promptWords || promptWords.length === 0) {
+    const prompt = promptWords?.length ? promptWords.join(' ') : null
+    const isChat = opts.chat || false
+
+    if (!prompt && !isChat) {
       aiCommand.help()
       return
     }
-    const prompt = promptWords.join(' ')
 
     requireAuth()
 
-    // Gather context (no spinner — fast local calls)
     const context = gatherContext(opts)
     const { config } = context
-    const repo = opts.repo || context.activeRepo
-
     const aiContext = { provider: opts.provider, model: opts.model }
 
-    // Early dedup check — before any LLM call
-    if (repo) {
-      const dedupSpinner = ora('Checking for duplicates...').start()
-      try {
-        const dedupResult = await checkDuplicate(repo, { title: prompt, agent: 'ai' })
-        dedupSpinner.stop()
+    // Check AI is available
+    if (!checkAvailable(config, aiContext)) {
+      console.warn(yellow('AI not configured.'))
+      console.warn(dim('Run `tissues config` to set up an AI provider.\n'))
+      return
+    }
 
-        if (dedupResult.action === 'block') {
-          const blockReasons = dedupResult.results.filter((r) => r.action === 'block')
-          for (const r of blockReasons) {
-            console.error(r.reason)
-            if (r.existingIssue?.number) {
-              console.error(dim(`  #${r.existingIssue.number}${r.existingIssue.title ? ` — ${r.existingIssue.title}` : ''}`))
-              if (r.existingIssue.url) console.error(dim(`  ${r.existingIssue.url}`))
-            }
-          }
-          console.error(red('Duplicate detected — issue not created.'))
-          process.exit(1)
-        }
+    // -----------------------------------------------------------------------
+    // Chat mode
+    // -----------------------------------------------------------------------
+    if (isChat) {
+      console.log(bold('\ntissues ai') + dim(' — chat mode (type "exit" to quit)\n'))
 
-        if (dedupResult.action === 'warn') {
-          console.warn(yellow('Similar issue(s) found:'))
-          for (const r of dedupResult.results.filter((r) => r.action === 'warn')) {
-            console.warn(r.reason)
-            if (r.existingIssue?.number) {
-              console.warn(dim(`  #${r.existingIssue.number}${r.existingIssue.title ? ` — ${r.existingIssue.title}` : ''}`))
-              if (r.existingIssue.url) console.warn(dim(`  ${r.existingIssue.url}`))
-            }
-          }
-          console.warn()
-          const proceed = await confirm({ message: 'Continue anyway?', default: false, theme })
-          if (!proceed) {
-            console.log(dim('Aborted.'))
-            process.exit(0)
-          }
-        }
-      } catch {
-        dedupSpinner.stop()
-        // Non-fatal — proceed without dedup
+      // If a prompt was given with --chat, process it first
+      if (prompt) {
+        await handleSingleTurn(prompt, config, context, opts)
       }
-    }
 
-    // If AI isn't configured at all, go straight to create with the prompt as title
-    if (!checkAvailable(config, aiContext)) {
-      console.warn(yellow('AI not configured — using prompt as issue title.'))
-      console.warn(dim('Run `tissues config` to set up an AI provider.\n'))
-      return fallbackToCreate(prompt, opts)
+      await runAgentLoop(config, context, {
+        provider: opts.provider,
+        model: opts.model,
+        onInput: async () => {
+          try {
+            const userInput = await input({ message: '>', theme })
+            return userInput
+          } catch {
+            return null // Ctrl+C
+          }
+        },
+        onOutput: (text) => {
+          console.log(text)
+          console.log()
+        },
+      })
+      return
     }
 
-    // Ask AI to build the create options
-    const systemPrompt = buildSystemPrompt(context)
-    const messages = [
-      { role: 'system', content: systemPrompt },
-      { role: 'user', content: prompt },
-    ]
+    // -----------------------------------------------------------------------
+    // Single-shot mode (backward compatible)
+    // -----------------------------------------------------------------------
+    await handleSingleTurn(prompt, config, context, opts)
+  })
+
+// ---------------------------------------------------------------------------
+// Single-turn handler
+// ---------------------------------------------------------------------------
+
+async function handleSingleTurn(prompt, config, context, opts) {
+  const repo = opts.repo || context.activeRepo
 
-    const { adapter, model } = resolveRoute(config, aiContext)
-    const spinner = ora('Building create command...').start()
-    let raw
+  // Early dedup check for create-like prompts
+  if (repo) {
     try {
-      raw = await adapter.complete(messages, { model, maxTokens: 2048 })
-      spinner.stop()
-    } catch (err) {
-      spinner.fail('AI failed')
-      if (/\b401\b/.test(err.message)) {
-        console.warn(red('  API key is invalid or expired.'))
-        console.warn(dim('  Run ') + cyan('tissues config') + dim(' to update your API key.'))
+      const dedupResult = await checkDuplicate(repo, { title: prompt, agent: 'ai' })
+      if (dedupResult.action === 'block') {
+        const blockReasons = dedupResult.results.filter(r => r.action === 'block')
+        for (const r of blockReasons) {
+          console.error(r.reason)
+          if (r.existingIssue?.number) {
+            console.error(dim(`  #${r.existingIssue.number}${r.existingIssue.title ? ` — ${r.existingIssue.title}` : ''}`))
+            if (r.existingIssue.url) console.error(dim(`  ${r.existingIssue.url}`))
+          }
+        }
+        console.error(red('Duplicate detected — issue not created.'))
+        process.exit(1)
       }
-      return fallbackToCreate(prompt, opts)
-    }
 
-    let plan
-    try {
-      plan = parseCreateOpts(raw)
+      if (dedupResult.action === 'warn') {
+        console.warn(yellow('Similar issue(s) found:'))
+        for (const r of dedupResult.results.filter(r => r.action === 'warn')) {
+          console.warn(r.reason)
+          if (r.existingIssue?.number) {
+            console.warn(dim(`  #${r.existingIssue.number}${r.existingIssue.title ? ` — ${r.existingIssue.title}` : ''}`))
+          }
+        }
+        console.warn()
+        const proceed = await confirm({ message: 'Continue anyway?', default: false, theme })
+        if (!proceed) {
+          console.log(dim('Aborted.'))
+          process.exit(0)
+        }
+      }
     } catch {
-      return fallbackToCreate(prompt, opts)
+      // Non-fatal dedup check
     }
+  }
 
-    // Show what create will receive
-    const planRepo = plan.repo || context.activeRepo
+  // Ask AI
+  const spinner = ora('Thinking...').start()
+  let agentResult
+  try {
+    agentResult = await runAgentSingleShot(prompt, config, context, {
+      provider: opts.provider,
+      model: opts.model,
+    })
+    spinner.stop()
+  } catch (err) {
+    spinner.fail('AI failed')
+    if (/\b401\b/.test(err.message)) {
+      console.warn(red('  API key is invalid or expired.'))
+      console.warn(dim('  Run ') + cyan('tissues config') + dim(' to update your API key.'))
+    } else {
+      console.warn(red(`  ${err.message}`))
+    }
+    console.warn(dim('  Tip: use --chat for interactive mode, or try rephrasing.\n'))
+    return
+  }
+
+  const { action, params } = agentResult
+
+  // Handle create_issue action (backward compatible preview + confirm flow)
+  if (action === 'create_issue') {
+    const planRepo = params.repo || context.activeRepo
     console.log()
     console.log(bold('  tissues create'))
-    console.log(`    ${dim('--title')}    ${plan.title}`)
+    console.log(`    ${dim('--title')}    ${params.title}`)
     if (planRepo) console.log(`    ${dim('--repo')}     ${planRepo}`)
-    if (plan.template) console.log(`    ${dim('--template')} ${plan.template}`)
-    if (plan.labels) console.log(`    ${dim('--labels')}   ${plan.labels}`)
-    if (plan.body) {
+    if (params.template) console.log(`    ${dim('--template')} ${params.template}`)
+    if (params.labels) console.log(`    ${dim('--labels')}   ${params.labels}`)
+    if (params.body) {
       console.log(`    ${dim('--body')}`)
-      const preview = plan.body.length > 400
-        ? plan.body.slice(0, 400) + dim('\n    ...(truncated)')
-        : plan.body
+      const preview = params.body.length > 400
+        ? params.body.slice(0, 400) + dim('\n    ...(truncated)')
+        : params.body
       for (const line of preview.split('\n')) {
         console.log(`    ${dim(line)}`)
       }
@@ -232,35 +209,34 @@ export const aiCommand = new Command('ai')
       }
     }
 
-    // Hand off to the same runCreate that `tissues create` uses
     try {
       const result = await runCreate({
         repo: planRepo,
-        title: plan.title,
-        body: plan.body || undefined,
-        labels: plan.labels || undefined,
-        template: plan.template || undefined,
+        title: params.title,
+        body: params.body || undefined,
+        labels: params.labels || undefined,
+        template: params.template || undefined,
+        enhancements: opts.enhancements || undefined,
       })
       if (result === null) process.exit(0)
     } catch (err) {
       process.exit(err.isAbort ? 0 : 1)
     }
-  })
+    return
+  }
 
-// ---------------------------------------------------------------------------
-// Fallback — AI unavailable, run create with the prompt as the title
-// ---------------------------------------------------------------------------
+  // Handle answer action
+  if (action === 'answer') {
+    console.log(params.text || params.content || '')
+    return
+  }
 
-async function fallbackToCreate(prompt, opts) {
-  try {
-    const result = await runCreate({
-      repo: opts.repo || undefined,
-      _titleDefault: prompt,
-      dryRun: opts.dryRun || false,
-      enhance: true, // let create's own AI enhancement try (it handles failure gracefully)
-    })
-    if (result === null) process.exit(0)
-  } catch (err) {
-    process.exit(err.isAbort ? 0 : 1)
+  // Handle other read-only actions
+  const result = await executeAction(action, params || {}, { ...context, config })
+  if (result.display) {
+    console.log(result.display)
+  } else if (result.result) {
+    console.log(typeof result.result === 'string' ? result.result : JSON.stringify(result.result, null, 2))
   }
 }
+