npm - tissues - Versions diffs - 0.3.0 - Mend

tissues 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/src/commands/create.js ADDED Viewed

@@ -0,0 +1,360 @@
+import { execSync } from 'node:child_process'
+import { Command } from 'commander'
+import { input, select, confirm } from '@inquirer/prompts'
+import { store } from '../lib/config.js'
+import { loadConfig, findRepoRoot } from '../lib/defaults.js'
+import { checkSafety, recordSuccess, recordFailure } from '../lib/safety.js'
+import { checkDuplicate, recordCreation } from '../lib/dedup.js'
+import { listTemplates, loadTemplate, renderTemplate } from '../lib/templates.js'
+import { renderAttribution } from '../lib/attribution.js'
+import { computeFingerprint } from '../lib/dedup.js'
+import { pickRepo } from '../lib/repo-picker.js'
+import { requireAuth, createIssue } from '../lib/gh.js'
+import chalk from 'chalk'
+import ora from 'ora'
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Print the circuit breaker state if it is not 'closed'.
+ *
+ * @param {string} circuitState
+ */
+function warnIfCircuitNotClosed(circuitState) {
+  if (circuitState === 'closed') return
+  const stateColor = circuitState === 'open' ? chalk.red : chalk.yellow
+  console.warn(
+    chalk.yellow('[safety]') +
+      ' Circuit breaker is ' +
+      stateColor(circuitState.toUpperCase()) +
+      '. Use `ghissue status` to view details.',
+  )
+}
+/**
+ * Format a dedup result for display, including link to existing issue when
+ * available.
+ *
+ * @param {{ action: string, reason: string, existingIssue?: { number: number, title: string, url: string } }} result
+ * @returns {string}
+ */
+function formatDedupResult(result) {
+  const parts = [result.reason]
+  if (result.existingIssue) {
+    const { number, title, url } = result.existingIssue
+    if (number) parts.push(`  Existing issue: #${number}${title ? ` — ${title}` : ''}`)
+    if (url) parts.push(`  URL: ${chalk.cyan(url)}`)
+  }
+  return parts.join('\n')
+}
+/**
+ * Run postCreate shell hook if configured.
+ *
+ * @param {string} hookCmd
+ * @param {{ repo: string, issueNumber: number, issueUrl: string }} ctx
+ */
+function runPostCreateHook(hookCmd, ctx) {
+  if (!hookCmd) return
+  try {
+    execSync(hookCmd, {
+      env: {
+        ...process.env,
+        GITISSUES_REPO: ctx.repo,
+        GITISSUES_ISSUE_NUMBER: String(ctx.issueNumber),
+        GITISSUES_ISSUE_URL: ctx.issueUrl,
+      },
+      stdio: 'inherit',
+    })
+  } catch (err) {
+    console.warn(chalk.yellow(`[hooks] postCreate hook failed: ${err.message}`))
+  }
+}
+// ---------------------------------------------------------------------------
+// AI enhancement stub
+// ---------------------------------------------------------------------------
+/**
+ * Enhance issue body with AI. Currently a structured placeholder.
+ * Wire up real AI (OpenAI / Anthropic) here.
+ *
+ * @param {string} title
+ * @param {string} description
+ * @param {string} templateBody - already-rendered template body to use as context
+ * @returns {Promise<string>}
+ */
+async function enhanceWithAI(title, description, templateBody) {
+  // TODO: wire up real AI (OpenAI / Anthropic)
+  // templateBody is provided as context for the AI to refine
+  return templateBody
+}
+// ---------------------------------------------------------------------------
+// Command
+// ---------------------------------------------------------------------------
+export const createCommand = new Command('create')
+  .description('Create a new GitHub issue')
+  .option('--repo <repo>', 'Repository override (owner/name)')
+  .option('--template <name>', 'Template to use (bug, feature, security, performance, refactor)')
+  .option('--agent <name>', 'Agent identifier for attribution (default: human)')
+  .option('--session <id>', 'Session ID for attribution')
+  .option('--title <title>', 'Issue title (skips interactive prompt)')
+  .option('--body <body>', 'Issue body / description (skips interactive prompt)')
+  .option('--labels <labels>', 'Comma-separated labels to apply')
+  .option('--force', 'Skip dedup warnings (still blocks on exact matches)')
+  .option('--dry-run', 'Check dedup and safety without creating the issue')
+  .action(async (opts) => {
+    // -----------------------------------------------------------------------
+    // 0. Ensure authenticated
+    // -----------------------------------------------------------------------
+    requireAuth()
+    // -----------------------------------------------------------------------
+    // 1. Resolve repo
+    // -----------------------------------------------------------------------
+    let repo = opts.repo
+    if (!repo) {
+      repo = store.get('activeRepo')
+    }
+    if (!repo) {
+      console.log(chalk.yellow('No active repo. Pick one:\n'))
+      repo = await pickRepo()
+      console.log()
+    }
+    // -----------------------------------------------------------------------
+    // 2. Load config
+    // -----------------------------------------------------------------------
+    const repoRoot = findRepoRoot()
+    const config = loadConfig(repoRoot)
+    // -----------------------------------------------------------------------
+    // 3. Check safety
+    // -----------------------------------------------------------------------
+    const agent = opts.agent ?? config.attribution?.defaultAgent ?? 'human'
+    const safetyResult = checkSafety(repo, agent, config.safety)
+    warnIfCircuitNotClosed(safetyResult.circuitState)
+    if (!safetyResult.allowed) {
+      recordFailure(repo, agent, config.safety)
+      console.error(chalk.red('Safety check failed:'), safetyResult.reason)
+      process.exit(1)
+    }
+    // -----------------------------------------------------------------------
+    // 4. Get inputs
+    // -----------------------------------------------------------------------
+    const title = opts.title ?? (await input({ message: 'Issue title' }))
+    if (!title || !title.trim()) {
+      console.error(chalk.red('Title is required.'))
+      process.exit(1)
+    }
+    const description =
+      opts.body ??
+      (await input({
+        message: 'Brief description (optional, used for AI enhancement)',
+      }))
+    // -----------------------------------------------------------------------
+    // 5. Pick template
+    // -----------------------------------------------------------------------
+    let templateName = opts.template
+    // Fall back to config default
+    if (!templateName) {
+      templateName = config.templates?.default ?? null
+    }
+    // If still unresolved and interactive, let user pick
+    if (!templateName) {
+      const available = listTemplates(repoRoot)
+      // Deduplicate by key (higher-priority sources shadow lower ones)
+      const seen = new Set()
+      const choices = []
+      for (const tpl of available) {
+        if (!seen.has(tpl.key)) {
+          seen.add(tpl.key)
+          choices.push({
+            name: `${tpl.name} ${chalk.dim(`(${tpl.source})`)}`,
+            value: tpl.key,
+          })
+        }
+      }
+      if (choices.length > 0) {
+        templateName = await select({
+          message: 'Choose a template',
+          choices,
+        })
+      } else {
+        templateName = 'default'
+      }
+    }
+    let template
+    try {
+      template = loadTemplate(templateName, repoRoot)
+    } catch (err) {
+      console.error(chalk.red(`Template error: ${err.message}`))
+      process.exit(1)
+    }
+    // -----------------------------------------------------------------------
+    // 6. Check dedup
+    // -----------------------------------------------------------------------
+    const session = opts.session ?? null
+    const dedupSpinner = ora('Checking for duplicates...').start()
+    let dedupResult
+    try {
+      dedupResult = await checkDuplicate(repo, {
+        title,
+        body: description,
+        agent,
+        // No idempotency key by default — callers who need deterministic keys
+        // can pass --session and combine with agent + title in future work
+      })
+      dedupSpinner.stop()
+    } catch (err) {
+      dedupSpinner.warn(`Dedup check failed (skipping): ${err.message}`)
+      dedupResult = { action: 'allow', results: [] }
+    }
+    if (dedupResult.action === 'block') {
+      recordFailure(repo, agent, config.safety)
+      console.error(chalk.red('Duplicate detected — issue not created.'))
+      for (const r of dedupResult.results.filter((r) => r.action === 'block')) {
+        console.error(formatDedupResult(r))
+      }
+      process.exit(1)
+    }
+    if (dedupResult.action === 'warn' && !opts.force) {
+      console.warn(chalk.yellow('\nSimilar issue(s) found:'))
+      for (const r of dedupResult.results.filter((r) => r.action === 'warn')) {
+        console.warn(formatDedupResult(r))
+      }
+      console.warn()
+      const proceed = await confirm({
+        message: 'Create anyway?',
+        default: false,
+      })
+      if (!proceed) {
+        console.log(chalk.dim('Aborted.'))
+        process.exit(0)
+      }
+    }
+    // -----------------------------------------------------------------------
+    // 7. Render template
+    // -----------------------------------------------------------------------
+    const renderedTemplate = renderTemplate(template.body, {
+      title,
+      description: description || '',
+      agent,
+      session: session || '',
+      date: new Date().toISOString().slice(0, 10),
+      repo,
+    })
+    // -----------------------------------------------------------------------
+    // 8. AI enhancement (stub — passes rendered template as context)
+    // -----------------------------------------------------------------------
+    let body = renderedTemplate
+    const aiSpinner = ora('Enhancing with AI...').start()
+    try {
+      body = await enhanceWithAI(title, description, renderedTemplate)
+      aiSpinner.succeed('Enhanced')
+    } catch {
+      aiSpinner.warn('AI enhancement unavailable — using template as-is')
+    }
+    // -----------------------------------------------------------------------
+    // 9. Add attribution
+    // -----------------------------------------------------------------------
+    const fingerprint = computeFingerprint(title, body)
+    const attribution = renderAttribution({
+      agent,
+      session: session ?? undefined,
+      trigger: 'cli-create',
+      fingerprint: `sha256:${fingerprint}`,
+    })
+    body = body.trimEnd() + '\n\n' + attribution
+    // -----------------------------------------------------------------------
+    // 10. Parse labels
+    // -----------------------------------------------------------------------
+    const labels = opts.labels
+      ? opts.labels
+          .split(',')
+          .map((l) => l.trim())
+          .filter(Boolean)
+      : []
+    // -----------------------------------------------------------------------
+    // Dry run — stop here
+    // -----------------------------------------------------------------------
+    if (opts.dryRun) {
+      console.log(chalk.cyan('\n--- DRY RUN ---'))
+      console.log(chalk.bold('Repo:   '), repo)
+      console.log(chalk.bold('Title:  '), title)
+      console.log(chalk.bold('Agent:  '), agent)
+      console.log(chalk.bold('Template:'), `${template.name} (${template.source})`)
+      if (labels.length > 0) console.log(chalk.bold('Labels: '), labels.join(', '))
+      console.log(chalk.bold('\nBody preview:'))
+      console.log(chalk.dim(body))
+      console.log(chalk.cyan('--- END DRY RUN (no issue created) ---\n'))
+      process.exit(0)
+    }
+    // -----------------------------------------------------------------------
+    // 11. Create issue
+    // -----------------------------------------------------------------------
+    const createSpinner = ora('Creating issue...').start()
+    let issue
+    try {
+      issue = await createIssue(repo, { title, body, labels })
+      createSpinner.succeed(`Issue created: ${chalk.cyan(issue.url)}`)
+    } catch (err) {
+      // GitHub API failures are NOT safety failures — do not record to circuit
+      createSpinner.fail(`Failed to create issue: ${err.message}`)
+      process.exit(1)
+    }
+    // -----------------------------------------------------------------------
+    // 12. Record success
+    // -----------------------------------------------------------------------
+    try {
+      await recordCreation(repo, {
+        title,
+        body,
+        issueNumber: issue.number,
+        agent,
+      })
+    } catch (err) {
+      // Non-fatal — dedup DB write failure shouldn't abort the command
+      console.warn(chalk.dim(`[dedup] Failed to record fingerprint: ${err.message}`))
+    }
+    recordSuccess(repo, agent)
+    // -----------------------------------------------------------------------
+    // Run postCreate hook if configured
+    // -----------------------------------------------------------------------
+    const hookCmd = config.hooks?.postCreate
+    if (hookCmd) {
+      runPostCreateHook(hookCmd, {
+        repo,
+        issueNumber: issue.number,
+        issueUrl: issue.url,
+      })
+    }
+  })

package/src/commands/list.js ADDED Viewed

@@ -0,0 +1,59 @@
+import { Command } from 'commander'
+import { search } from '@inquirer/prompts'
+import { store } from '../lib/config.js'
+import { pickRepo } from '../lib/repo-picker.js'
+import { requireAuth, listIssues } from '../lib/gh.js'
+import chalk from 'chalk'
+import ora from 'ora'
+import { execSync } from 'child_process'
+export const listCommand = new Command('list')
+  .description('List open issues in the active repository')
+  .option('--repo <repo>', 'Repository override (owner/name)')
+  .action(async (opts) => {
+    requireAuth()
+    let repo = opts.repo
+    if (!repo) {
+      repo = store.get('activeRepo')
+    }
+    if (!repo) {
+      console.log(chalk.yellow('No active repo. Pick one:\n'))
+      repo = await pickRepo()
+      console.log()
+    }
+    const spinner = ora('Fetching issues...').start()
+    const issues = listIssues(repo)
+    spinner.stop()
+    if (issues.length === 0) {
+      console.log(chalk.dim('No open issues.'))
+      return
+    }
+    const selected = await search({
+      message: `Open issues in ${chalk.cyan(repo)}`,
+      source: (input) => {
+        const term = (input || '').toLowerCase()
+        return issues
+          .filter(
+            (i) =>
+              i.title.toLowerCase().includes(term) ||
+              String(i.number).includes(term),
+          )
+          .map((i) => ({
+            name: `#${i.number} ${i.title}`,
+            value: i.url,
+          }))
+      },
+    })
+    // Open in browser
+    try {
+      execSync(`open "${selected}"`)
+    } catch {
+      console.log(`\nOpen: ${chalk.cyan(selected)}`)
+    }
+  })

package/src/commands/open.js ADDED Viewed

@@ -0,0 +1,17 @@
+import { Command } from 'commander'
+import { pickRepo } from '../lib/repo-picker.js'
+import { setConfig } from '../lib/config.js'
+import chalk from 'chalk'
+export const openCommand = new Command('open')
+  .description('Set the active repository context')
+  .argument('[repo]', 'Repository in owner/name format (e.g. owner/repo)')
+  .action(async (repo) => {
+    if (repo) {
+      setConfig({ activeRepo: repo })
+      console.log(chalk.green(`✓ Active repo set to ${repo}`))
+    } else {
+      const selected = await pickRepo()
+      console.log(chalk.green(`\n✓ Active repo set to ${selected}`))
+    }
+  })

package/src/commands/status.js ADDED Viewed

@@ -0,0 +1,166 @@
+import { Command } from 'commander'
+import { store } from '../lib/config.js'
+import { loadConfig, findRepoRoot } from '../lib/defaults.js'
+import { getSafetyStatus, forceReset } from '../lib/safety.js'
+import { getDb } from '../lib/db.js'
+import { getCircuitState, countRecentEvents, probeCircuit } from '../lib/db.js'
+import chalk from 'chalk'
+/**
+ * Query fingerprint count and last creation time for a repo from the DB.
+ *
+ * @param {string} repo
+ * @returns {{ fingerprintCount: number, lastCreatedAt: string|null }}
+ */
+function getDbStats(repo) {
+  const db = getDb()
+  const fpRow = db
+    .prepare(`SELECT COUNT(*) AS cnt FROM fingerprints WHERE repo = ?`)
+    .get(repo)
+  const fingerprintCount = fpRow ? fpRow.cnt : 0
+  const lastRow = db
+    .prepare(
+      `SELECT created_at FROM rate_events
+        WHERE repo = ? AND event_type = 'create'
+        ORDER BY created_at DESC
+        LIMIT 1`
+    )
+    .get(repo)
+  const lastCreatedAt = lastRow ? lastRow.created_at : null
+  return { fingerprintCount, lastCreatedAt }
+}
+/**
+ * Format an ISO timestamp as a human-readable "X minutes/hours/days ago" string.
+ *
+ * @param {string} isoString - SQLite datetime string (UTC, no trailing Z)
+ * @returns {string}
+ */
+function timeAgo(isoString) {
+  // SQLite stores datetime('now') without a trailing 'Z'; add it for correct parsing.
+  const ts = new Date(isoString.endsWith('Z') ? isoString : isoString + 'Z')
+  const diffMs = Date.now() - ts.getTime()
+  if (diffMs < 0) return 'just now'
+  const seconds = Math.floor(diffMs / 1000)
+  if (seconds < 60) return `${seconds} second${seconds === 1 ? '' : 's'} ago`
+  const minutes = Math.floor(diffMs / 60_000)
+  if (minutes < 60) return `${minutes} minute${minutes === 1 ? '' : 's'} ago`
+  const hours = Math.floor(diffMs / 3_600_000)
+  if (hours < 24) return `${hours} hour${hours === 1 ? '' : 's'} ago`
+  const days = Math.floor(diffMs / 86_400_000)
+  return `${days} day${days === 1 ? '' : 's'} ago`
+}
+/**
+ * Chalk-color a circuit breaker state label.
+ *
+ * @param {string} state - 'closed' | 'open' | 'half-open'
+ * @returns {string}
+ */
+function colorCircuitState(state) {
+  if (state === 'closed') return chalk.green('closed') + ' ' + chalk.green('✓')
+  if (state === 'open') return chalk.red('open') + ' ' + chalk.red('✗')
+  return chalk.yellow('half-open') + ' ' + chalk.yellow('~')
+}
+export const statusCommand = new Command('status')
+  .description('Show safety status (circuit breaker + rate limits) for the active repo')
+  .option('--repo <repo>', 'Repository override (owner/name)')
+  .option('--agent <name>', "Check a specific agent's status (default: 'human')", 'human')
+  .option('--reset', 'Force-reset the circuit breaker to closed')
+  .action((opts) => {
+    let repo = opts.repo
+    if (!repo) {
+      repo = store.get('activeRepo')
+    }
+    if (!repo) {
+      console.error(chalk.red('No active repo. Set one with: ghissue open'))
+      process.exit(1)
+    }
+    const agent = opts.agent
+    // Handle --reset before displaying status
+    if (opts.reset) {
+      forceReset(repo, agent)
+      console.log(chalk.green(`Circuit breaker reset to closed for ${repo} / ${agent}`))
+    }
+    const config = loadConfig(findRepoRoot())
+    const safetyCfg = config.safety ?? {}
+    const cfg = {
+      maxPerHour: safetyCfg.maxPerHour ?? 10,
+      burstLimit: safetyCfg.burstLimit ?? 5,
+      burstWindowMinutes: safetyCfg.burstWindowMinutes ?? 5,
+      globalMaxPerHour: safetyCfg.globalMaxPerHour ?? 30,
+    }
+    // Probe the circuit so open → half-open transitions happen before we read state
+    probeCircuit(repo, agent)
+    const circuit = getCircuitState(repo, agent)
+    const circuitState = circuit.status ?? 'closed'
+    const agentHourCount = countRecentEvents(repo, agent, 60)
+    const agentBurstCount = countRecentEvents(repo, agent, cfg.burstWindowMinutes)
+    // Global count across all agents
+    const db = getDb()
+    const cutoff = new Date(Date.now() - 60 * 60_000).toISOString()
+    const globalRow = db
+      .prepare(
+        `SELECT COUNT(*) AS cnt
+           FROM rate_events
+          WHERE repo = ? AND event_type = 'create' AND created_at >= ?`
+      )
+      .get(repo, cutoff)
+    const globalHourCount = globalRow ? globalRow.cnt : 0
+    const { fingerprintCount, lastCreatedAt } = getDbStats(repo)
+    const agentHourRemaining = Math.max(0, cfg.maxPerHour - agentHourCount)
+    const globalHourRemaining = Math.max(0, cfg.globalMaxPerHour - globalHourCount)
+    console.log(`Circuit Breaker: ${colorCircuitState(circuitState)}`)
+    if (circuitState === 'open' && circuit.cooldownUntil) {
+      const until = new Date(
+        circuit.cooldownUntil.endsWith('Z') ? circuit.cooldownUntil : circuit.cooldownUntil + 'Z'
+      )
+      const diffMs = until - Date.now()
+      if (diffMs > 0) {
+        const mins = Math.ceil(diffMs / 60_000)
+        console.log(chalk.dim(`  Cooldown: ${mins} minute${mins === 1 ? '' : 's'} remaining`))
+      }
+    }
+    console.log(
+      `Rate Limit: ${agentHourCount}/${cfg.maxPerHour} per hour` +
+        chalk.dim(` (${agentHourRemaining} remaining)`)
+    )
+    console.log(
+      `Burst: ${agentBurstCount}/${cfg.burstLimit} in last ${cfg.burstWindowMinutes} min`
+    )
+    console.log(
+      `Global: ${globalHourCount}/${cfg.globalMaxPerHour} per hour` +
+        chalk.dim(` (${globalHourRemaining} remaining)`)
+    )
+    console.log()
+    if (lastCreatedAt) {
+      console.log(`Last issue created: ${timeAgo(lastCreatedAt)}`)
+    } else {
+      console.log(chalk.dim('Last issue created: never'))
+    }
+    console.log(`Fingerprints stored: ${fingerprintCount}`)
+  })