Security hardening, bug fixes, and unit tests

Security:
- Remove shell(cat/head/tail/grep/wc/jq) and --allow-all-paths from Copilot CLI
  Only shell(git) is granted — prevents secret exfiltration via prompt injection
- Pass minimal env to subprocess (PATH, HOME, GITHUB_TOKEN only)
  No longer spreads process.env which leaked all secrets
- Add prompt injection armor: security notice, <pr-data> delimiters,
  code-fenced PR bodies, heading/tag sanitization
- Remove dead temp file write that left sensitive data on disk

Bug fixes:
- Fix GITHUB_TOKEN fallback: COPILOT_GITHUB_TOKEN || GITHUB_TOKEN || ''
- Fix JSON parser: search for valid {"entries"} objects instead of greedy regex
  Handles AI output with braces before the JSON block
- Fix squash regex in github-api strategy: use $ anchor + first line only
- Warn when GitHub compare API may truncate at 250 commits
- Add prompt size warning when over 100K chars
- Add 5-minute timeout for Copilot CLI execution
- Validate entries field is an array before returning

Tests (34 passing):
- outputs.test.ts: parseOutput edge cases, formatAsMarkdown grouping
- prompt.test.ts: security armor, sanitization, truncation, code fences
- inputs.test.ts: input parsing, defaults, validation

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: tidy-dev

__tests__/inputs.test.ts

@@ -0,0 +1,79 @@
+// Mock @actions/core before any imports
+jest.mock('@actions/core', () => ({
+  warning: jest.fn(),
+  debug: jest.fn(),
+  info: jest.fn(),
+  getInput: jest.fn()
+}))
+
+import * as core from '@actions/core'
+import {getInputs} from '../src/inputs'
+
+const mockGetInput = core.getInput as jest.MockedFunction<typeof core.getInput>
+
+describe('getInputs', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    // Default mock implementation — no inputs set
+    mockGetInput.mockReturnValue('')
+  })
+
+  it('requires base-ref', () => {
+    mockGetInput.mockImplementation((name: string) => {
+      if (name === 'base-ref') return ''
+      return ''
+    })
+    expect(() => getInputs()).toThrow('base-ref is required')
+  })
+
+  it('parses all inputs correctly', () => {
+    mockGetInput.mockImplementation((name: string) => {
+      switch (name) {
+        case 'base-ref':
+          return 'v1.0'
+        case 'head-ref':
+          return 'v2.0'
+        case 'instructions':
+          return 'guide.md'
+        case 'model':
+          return 'gpt-4'
+        case 'pr-strategy':
+          return 'github-api'
+        default:
+          return ''
+      }
+    })
+    const inputs = getInputs()
+    expect(inputs.baseRef).toBe('v1.0')
+    expect(inputs.headRef).toBe('v2.0')
+    expect(inputs.model).toBe('gpt-4')
+    expect(inputs.prStrategy).toBe('github-api')
+  })
+
+  it('defaults head-ref to HEAD', () => {
+    mockGetInput.mockImplementation((name: string) => {
+      if (name === 'base-ref') return 'v1.0'
+      return ''
+    })
+    const inputs = getInputs()
+    expect(inputs.headRef).toBe('HEAD')
+  })
+
+  it('defaults pr-strategy to merge-commits', () => {
+    mockGetInput.mockImplementation((name: string) => {
+      if (name === 'base-ref') return 'v1.0'
+      return ''
+    })
+    const inputs = getInputs()
+    expect(inputs.prStrategy).toBe('merge-commits')
+  })
+
+  it('rejects invalid pr-strategy', () => {
+    mockGetInput.mockImplementation((name: string) => {
+      if (name === 'base-ref') return 'v1.0'
+      if (name === 'pr-strategy') return 'invalid'
+      return ''
+    })
+    expect(() => getInputs()).toThrow('Invalid pr-strategy')
+  })
+})

__tests__/outputs.test.ts

@@ -0,0 +1,223 @@
+// Mock @actions/core before any imports
+jest.mock('@actions/core', () => ({
+  warning: jest.fn(),
+  debug: jest.fn(),
+  info: jest.fn(),
+  setOutput: jest.fn()
+}))
+
+import {parseOutput, formatAsMarkdown, ParsedOutput} from '../src/outputs'
+
+describe('parseOutput', () => {
+  it('parses clean JSON output', () => {
+    const input = JSON.stringify({
+      entries: [
+        {description: 'Add feature X', pr: 123, author: 'octocat'}
+      ],
+      uncertainEntries: [],
+      skippedPRs: []
+    })
+    const result = parseOutput(input)
+    expect(result.entries).toHaveLength(1)
+    expect(result.entries[0].description).toBe('Add feature X')
+    expect(result.entries[0].pr).toBe(123)
+  })
+
+  it('finds JSON embedded in surrounding text', () => {
+    const input =
+      'Here is my analysis of the PRs:\n\n' +
+      JSON.stringify({
+        entries: [{description: 'Fix bug', pr: 456, author: 'mona'}],
+        uncertainEntries: []
+      }) +
+      '\n\nDone!'
+    const result = parseOutput(input)
+    expect(result.entries).toHaveLength(1)
+    expect(result.entries[0].pr).toBe(456)
+  })
+
+  it('handles text with braces before the actual JSON', () => {
+    // This was a known bug — greedy regex matched the wrong opening brace
+    const input =
+      'I analyzed {5 changes} and found interesting results.\n\n' +
+      JSON.stringify({
+        entries: [{description: 'Update deps', pr: 789, author: 'bot'}],
+        uncertainEntries: []
+      })
+    const result = parseOutput(input)
+    expect(result.entries).toHaveLength(1)
+    expect(result.entries[0].pr).toBe(789)
+  })
+
+  it('handles JSON with code blocks containing braces', () => {
+    const input =
+      'The diff shows `if (x) { return }` patterns.\n' +
+      JSON.stringify({
+        entries: [{description: 'Refactor conditionals', pr: 100, author: 'dev'}],
+        uncertainEntries: []
+      })
+    const result = parseOutput(input)
+    expect(result.entries).toHaveLength(1)
+  })
+
+  it('returns empty results for no JSON', () => {
+    const result = parseOutput('No JSON here at all')
+    expect(result.entries).toHaveLength(0)
+    expect(result.uncertainEntries).toHaveLength(0)
+    expect(result.skippedPRs).toHaveLength(0)
+  })
+
+  it('returns empty results for invalid JSON with "entries"', () => {
+    const result = parseOutput('{entries: not valid json}')
+    expect(result.entries).toHaveLength(0)
+  })
+
+  it('returns empty results when entries is not an array', () => {
+    const input = JSON.stringify({entries: 'not an array'})
+    const result = parseOutput(input)
+    expect(result.entries).toHaveLength(0)
+  })
+
+  it('handles missing uncertainEntries and skippedPRs gracefully', () => {
+    const input = JSON.stringify({
+      entries: [{description: 'Test', pr: 1, author: 'a'}]
+    })
+    const result = parseOutput(input)
+    expect(result.entries).toHaveLength(1)
+    expect(result.uncertainEntries).toHaveLength(0)
+    expect(result.skippedPRs).toHaveLength(0)
+  })
+
+  it('handles nested JSON strings in descriptions', () => {
+    const input = JSON.stringify({
+      entries: [
+        {
+          description: 'Parse {"key": "value"} objects correctly',
+          pr: 42,
+          author: 'dev'
+        }
+      ],
+      uncertainEntries: []
+    })
+    const result = parseOutput(input)
+    expect(result.entries).toHaveLength(1)
+    expect(result.entries[0].pr).toBe(42)
+  })
+
+  it('parses entries with tags', () => {
+    const input = JSON.stringify({
+      entries: [
+        {
+          description: 'Add new command',
+          pr: 10,
+          author: 'dev',
+          tag: '✨ Features'
+        }
+      ],
+      uncertainEntries: []
+    })
+    const result = parseOutput(input)
+    expect(result.entries[0].tag).toBe('✨ Features')
+  })
+
+  it('handles empty string input', () => {
+    const result = parseOutput('')
+    expect(result.entries).toHaveLength(0)
+  })
+})
+
+describe('formatAsMarkdown', () => {
+  it('formats flat entries without tags', () => {
+    const output: ParsedOutput = {
+      entries: [
+        {description: 'Add feature X', pr: 123, author: 'octocat'},
+        {description: 'Fix bug Y', pr: 456, author: 'mona'}
+      ],
+      uncertainEntries: [],
+      skippedPRs: []
+    }
+    const md = formatAsMarkdown(output)
+    expect(md).toBe(
+      '- Add feature X (#123)\n- Fix bug Y (#456)'
+    )
+  })
+
+  it('groups entries by tag when tags are present', () => {
+    const output: ParsedOutput = {
+      entries: [
+        {description: 'New command', pr: 1, author: 'a', tag: '✨ Features'},
+        {description: 'Fix crash', pr: 2, author: 'b', tag: '🐛 Fixes'},
+        {description: 'Another feature', pr: 3, author: 'c', tag: '✨ Features'}
+      ],
+      uncertainEntries: [],
+      skippedPRs: []
+    }
+    const md = formatAsMarkdown(output)
+    expect(md).toContain('### ✨ Features')
+    expect(md).toContain('### 🐛 Fixes')
+    expect(md).toContain('- New command (#1)')
+    expect(md).toContain('- Another feature (#3)')
+    expect(md).toContain('- Fix crash (#2)')
+  })
+
+  it('puts untagged entries under "Other" when some entries have tags', () => {
+    const output: ParsedOutput = {
+      entries: [
+        {description: 'Tagged', pr: 1, author: 'a', tag: '✨ Features'},
+        {description: 'Untagged', pr: 2, author: 'b'}
+      ],
+      uncertainEntries: [],
+      skippedPRs: []
+    }
+    const md = formatAsMarkdown(output)
+    expect(md).toContain('### ✨ Features')
+    expect(md).toContain('### Other')
+    expect(md).toContain('- Untagged (#2)')
+  })
+
+  it('includes uncertain entries section', () => {
+    const output: ParsedOutput = {
+      entries: [{description: 'Sure thing', pr: 1, author: 'a'}],
+      uncertainEntries: [
+        {
+          description: 'Maybe this?',
+          pr: 2,
+          author: 'b',
+          reason: 'PR body was empty'
+        }
+      ],
+      skippedPRs: []
+    }
+    const md = formatAsMarkdown(output)
+    expect(md).toContain('### Needs Review')
+    expect(md).toContain('Maybe this?')
+    expect(md).toContain('_PR body was empty_')
+  })
+
+  it('handles empty entries', () => {
+    const output: ParsedOutput = {
+      entries: [],
+      uncertainEntries: [],
+      skippedPRs: []
+    }
+    const md = formatAsMarkdown(output)
+    expect(md).toBe('')
+  })
+
+  it('preserves tag insertion order', () => {
+    const output: ParsedOutput = {
+      entries: [
+        {description: 'Fix A', pr: 1, author: 'a', tag: '🐛 Fixes'},
+        {description: 'Feature B', pr: 2, author: 'b', tag: '✨ Features'},
+        {description: 'Fix C', pr: 3, author: 'c', tag: '🐛 Fixes'}
+      ],
+      uncertainEntries: [],
+      skippedPRs: []
+    }
+    const md = formatAsMarkdown(output)
+    // Fixes should come before Features because first entry was a Fix
+    const fixesIdx = md.indexOf('### 🐛 Fixes')
+    const featuresIdx = md.indexOf('### ✨ Features')
+    expect(fixesIdx).toBeLessThan(featuresIdx)
+  })
+})