Compare commits
1 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 coderabbitai[bot]
|
f0a490c5af |
@@ -1,3 +0,0 @@
|
||||
# These are supported funding model platforms
|
||||
|
||||
github: AndyMik90
|
||||
@@ -1,8 +1,8 @@
|
||||
blank_issues_enabled: false
|
||||
contact_links:
|
||||
- name: 💡 Feature Request
|
||||
url: https://github.com/AndyMik90/Auto-Claude/discussions
|
||||
url: https://github.com/AndyMik90/Auto-Claude/discussions/new?category=ideas
|
||||
about: Suggest new features in GitHub Discussions
|
||||
- name: 💬 Discord Community
|
||||
url: https://discord.gg/QhRnz9m5HE
|
||||
url: https://discord.gg/KCXaPBr4Dj
|
||||
about: Questions and discussions - join our Discord!
|
||||
|
||||
@@ -5,7 +5,7 @@ body:
|
||||
- type: markdown
|
||||
attributes:
|
||||
value: |
|
||||
**Before asking:** Check [Discord](https://discord.gg/QhRnz9m5HE) - your question may already be answered there!
|
||||
**Before asking:** Check [Discord](https://discord.gg/KCXaPBr4Dj) - your question may already be answered there!
|
||||
|
||||
- type: checkboxes
|
||||
id: checklist
|
||||
|
||||
@@ -1,37 +0,0 @@
|
||||
version: 2
|
||||
updates:
|
||||
# Python dependencies
|
||||
- package-ecosystem: pip
|
||||
directory: /apps/backend
|
||||
schedule:
|
||||
interval: weekly
|
||||
open-pull-requests-limit: 5
|
||||
labels:
|
||||
- dependencies
|
||||
- python
|
||||
commit-message:
|
||||
prefix: "chore(deps)"
|
||||
|
||||
# npm dependencies
|
||||
- package-ecosystem: npm
|
||||
directory: /apps/frontend
|
||||
schedule:
|
||||
interval: weekly
|
||||
open-pull-requests-limit: 5
|
||||
labels:
|
||||
- dependencies
|
||||
- javascript
|
||||
commit-message:
|
||||
prefix: "chore(deps)"
|
||||
|
||||
# GitHub Actions
|
||||
- package-ecosystem: github-actions
|
||||
directory: /
|
||||
schedule:
|
||||
interval: weekly
|
||||
open-pull-requests-limit: 5
|
||||
labels:
|
||||
- dependencies
|
||||
- ci
|
||||
commit-message:
|
||||
prefix: "ci(deps)"
|
||||
@@ -1,4 +1,4 @@
|
||||
name: Issue Auto Label
|
||||
name: Auto Label
|
||||
|
||||
on:
|
||||
issues:
|
||||
@@ -32,44 +32,62 @@ jobs:
|
||||
|
||||
echo "Valid beta version: $VERSION"
|
||||
|
||||
create-tag:
|
||||
name: Create beta tag
|
||||
update-version:
|
||||
name: Update package.json version
|
||||
needs: validate-version
|
||||
runs-on: ubuntu-latest
|
||||
permissions:
|
||||
contents: write
|
||||
outputs:
|
||||
version: ${{ github.event.inputs.version }}
|
||||
version: ${{ steps.version.outputs.version }}
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
with:
|
||||
ref: develop
|
||||
token: ${{ secrets.GITHUB_TOKEN }}
|
||||
|
||||
- name: Create and push tag
|
||||
- name: Setup Node.js
|
||||
uses: actions/setup-node@v4
|
||||
with:
|
||||
node-version: '24'
|
||||
|
||||
- name: Update package.json version
|
||||
id: version
|
||||
run: |
|
||||
VERSION="${{ github.event.inputs.version }}"
|
||||
|
||||
# Update frontend package.json
|
||||
cd apps/frontend
|
||||
npm version "$VERSION" --no-git-tag-version
|
||||
|
||||
echo "version=$VERSION" >> $GITHUB_OUTPUT
|
||||
echo "Updated package.json to version $VERSION"
|
||||
|
||||
- name: Commit version bump
|
||||
if: ${{ github.event.inputs.dry_run != 'true' }}
|
||||
run: |
|
||||
VERSION="${{ github.event.inputs.version }}"
|
||||
git config user.name "github-actions[bot]"
|
||||
git config user.email "github-actions[bot]@users.noreply.github.com"
|
||||
# Stage all changed files in frontend directory (handles package-lock.json if it exists)
|
||||
git add -A apps/frontend/
|
||||
git commit -m "chore: bump version to $VERSION for beta release"
|
||||
git push origin develop
|
||||
|
||||
- name: Create and push tag
|
||||
if: ${{ github.event.inputs.dry_run != 'true' }}
|
||||
run: |
|
||||
VERSION="${{ github.event.inputs.version }}"
|
||||
git tag -a "v$VERSION" -m "Beta release v$VERSION"
|
||||
git push origin "v$VERSION"
|
||||
echo "Created tag v$VERSION"
|
||||
|
||||
- name: Create tag only (dry run)
|
||||
if: ${{ github.event.inputs.dry_run == 'true' }}
|
||||
run: |
|
||||
VERSION="${{ github.event.inputs.version }}"
|
||||
echo "DRY RUN: Would create tag v$VERSION"
|
||||
|
||||
# Intel build on Intel runner for native compilation
|
||||
build-macos-intel:
|
||||
needs: create-tag
|
||||
needs: update-version
|
||||
runs-on: macos-15-intel
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
with:
|
||||
# Use tag for real releases, develop branch for dry runs
|
||||
ref: ${{ github.event.inputs.dry_run == 'true' && 'develop' || format('v{0}', needs.create-tag.outputs.version) }}
|
||||
ref: v${{ needs.update-version.outputs.version }}
|
||||
|
||||
- name: Setup Node.js
|
||||
uses: actions/setup-node@v4
|
||||
@@ -89,21 +107,11 @@ jobs:
|
||||
- name: Install dependencies
|
||||
run: cd apps/frontend && npm ci
|
||||
|
||||
- name: Cache bundled Python
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
path: apps/frontend/python-runtime
|
||||
key: python-bundle-${{ runner.os }}-x64-3.12.8
|
||||
restore-keys: |
|
||||
python-bundle-${{ runner.os }}-x64-
|
||||
|
||||
- name: Build application
|
||||
run: cd apps/frontend && npm run build
|
||||
|
||||
- name: Package macOS (Intel)
|
||||
run: |
|
||||
VERSION="${{ needs.create-tag.outputs.version }}"
|
||||
cd apps/frontend && npm run package:mac -- --x64 --config.extraMetadata.version="$VERSION"
|
||||
run: cd apps/frontend && npm run package:mac -- --arch=x64
|
||||
env:
|
||||
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
CSC_LINK: ${{ secrets.MAC_CERTIFICATE }}
|
||||
@@ -138,17 +146,15 @@ jobs:
|
||||
path: |
|
||||
apps/frontend/dist/*.dmg
|
||||
apps/frontend/dist/*.zip
|
||||
apps/frontend/dist/*.yml
|
||||
|
||||
# Apple Silicon build on ARM64 runner for native compilation
|
||||
build-macos-arm64:
|
||||
needs: create-tag
|
||||
needs: update-version
|
||||
runs-on: macos-15
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
with:
|
||||
# Use tag for real releases, develop branch for dry runs
|
||||
ref: ${{ github.event.inputs.dry_run == 'true' && 'develop' || format('v{0}', needs.create-tag.outputs.version) }}
|
||||
ref: v${{ needs.update-version.outputs.version }}
|
||||
|
||||
- name: Setup Node.js
|
||||
uses: actions/setup-node@v4
|
||||
@@ -168,21 +174,11 @@ jobs:
|
||||
- name: Install dependencies
|
||||
run: cd apps/frontend && npm ci
|
||||
|
||||
- name: Cache bundled Python
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
path: apps/frontend/python-runtime
|
||||
key: python-bundle-${{ runner.os }}-arm64-3.12.8
|
||||
restore-keys: |
|
||||
python-bundle-${{ runner.os }}-arm64-
|
||||
|
||||
- name: Build application
|
||||
run: cd apps/frontend && npm run build
|
||||
|
||||
- name: Package macOS (Apple Silicon)
|
||||
run: |
|
||||
VERSION="${{ needs.create-tag.outputs.version }}"
|
||||
cd apps/frontend && npm run package:mac -- --arm64 --config.extraMetadata.version="$VERSION"
|
||||
run: cd apps/frontend && npm run package:mac -- --arch=arm64
|
||||
env:
|
||||
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
CSC_LINK: ${{ secrets.MAC_CERTIFICATE }}
|
||||
@@ -217,16 +213,14 @@ jobs:
|
||||
path: |
|
||||
apps/frontend/dist/*.dmg
|
||||
apps/frontend/dist/*.zip
|
||||
apps/frontend/dist/*.yml
|
||||
|
||||
build-windows:
|
||||
needs: create-tag
|
||||
needs: update-version
|
||||
runs-on: windows-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
with:
|
||||
# Use tag for real releases, develop branch for dry runs
|
||||
ref: ${{ github.event.inputs.dry_run == 'true' && 'develop' || format('v{0}', needs.create-tag.outputs.version) }}
|
||||
ref: v${{ needs.update-version.outputs.version }}
|
||||
|
||||
- name: Setup Node.js
|
||||
uses: actions/setup-node@v4
|
||||
@@ -247,22 +241,11 @@ jobs:
|
||||
- name: Install dependencies
|
||||
run: cd apps/frontend && npm ci
|
||||
|
||||
- name: Cache bundled Python
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
path: apps/frontend/python-runtime
|
||||
key: python-bundle-${{ runner.os }}-x64-3.12.8
|
||||
restore-keys: |
|
||||
python-bundle-${{ runner.os }}-x64-
|
||||
|
||||
- name: Build application
|
||||
run: cd apps/frontend && npm run build
|
||||
|
||||
- name: Package Windows
|
||||
shell: bash
|
||||
run: |
|
||||
VERSION="${{ needs.create-tag.outputs.version }}"
|
||||
cd apps/frontend && npm run package:win -- --config.extraMetadata.version="$VERSION"
|
||||
run: cd apps/frontend && npm run package:win
|
||||
env:
|
||||
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
CSC_LINK: ${{ secrets.WIN_CERTIFICATE }}
|
||||
@@ -274,16 +257,14 @@ jobs:
|
||||
name: windows-builds
|
||||
path: |
|
||||
apps/frontend/dist/*.exe
|
||||
apps/frontend/dist/*.yml
|
||||
|
||||
build-linux:
|
||||
needs: create-tag
|
||||
needs: update-version
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
with:
|
||||
# Use tag for real releases, develop branch for dry runs
|
||||
ref: ${{ github.event.inputs.dry_run == 'true' && 'develop' || format('v{0}', needs.create-tag.outputs.version) }}
|
||||
ref: v${{ needs.update-version.outputs.version }}
|
||||
|
||||
- name: Setup Node.js
|
||||
uses: actions/setup-node@v4
|
||||
@@ -303,21 +284,11 @@ jobs:
|
||||
- name: Install dependencies
|
||||
run: cd apps/frontend && npm ci
|
||||
|
||||
- name: Cache bundled Python
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
path: apps/frontend/python-runtime
|
||||
key: python-bundle-${{ runner.os }}-x64-3.12.8
|
||||
restore-keys: |
|
||||
python-bundle-${{ runner.os }}-x64-
|
||||
|
||||
- name: Build application
|
||||
run: cd apps/frontend && npm run build
|
||||
|
||||
- name: Package Linux
|
||||
run: |
|
||||
VERSION="${{ needs.create-tag.outputs.version }}"
|
||||
cd apps/frontend && npm run package:linux -- --config.extraMetadata.version="$VERSION"
|
||||
run: cd apps/frontend && npm run package:linux
|
||||
env:
|
||||
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
|
||||
@@ -328,10 +299,9 @@ jobs:
|
||||
path: |
|
||||
apps/frontend/dist/*.AppImage
|
||||
apps/frontend/dist/*.deb
|
||||
apps/frontend/dist/*.yml
|
||||
|
||||
create-release:
|
||||
needs: [create-tag, build-macos-intel, build-macos-arm64, build-windows, build-linux]
|
||||
needs: [update-version, build-macos-intel, build-macos-arm64, build-windows, build-linux]
|
||||
runs-on: ubuntu-latest
|
||||
if: ${{ github.event.inputs.dry_run != 'true' }}
|
||||
permissions:
|
||||
@@ -339,7 +309,7 @@ jobs:
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
with:
|
||||
ref: v${{ needs.create-tag.outputs.version }}
|
||||
ref: v${{ needs.update-version.outputs.version }}
|
||||
fetch-depth: 0
|
||||
|
||||
- name: Download all artifacts
|
||||
@@ -350,7 +320,7 @@ jobs:
|
||||
- name: Flatten and validate artifacts
|
||||
run: |
|
||||
mkdir -p release-assets
|
||||
find dist -type f \( -name "*.dmg" -o -name "*.zip" -o -name "*.exe" -o -name "*.AppImage" -o -name "*.deb" -o -name "*.yml" \) -exec cp {} release-assets/ \;
|
||||
find dist -type f \( -name "*.dmg" -o -name "*.zip" -o -name "*.exe" -o -name "*.AppImage" -o -name "*.deb" \) -exec cp {} release-assets/ \;
|
||||
|
||||
# Validate that at least one artifact was copied
|
||||
artifact_count=$(find release-assets -type f \( -name "*.dmg" -o -name "*.zip" -o -name "*.exe" -o -name "*.AppImage" -o -name "*.deb" \) | wc -l)
|
||||
@@ -371,10 +341,10 @@ jobs:
|
||||
- name: Create Beta Release
|
||||
uses: softprops/action-gh-release@v2
|
||||
with:
|
||||
tag_name: v${{ needs.create-tag.outputs.version }}
|
||||
name: v${{ needs.create-tag.outputs.version }} (Beta)
|
||||
tag_name: v${{ needs.update-version.outputs.version }}
|
||||
name: v${{ needs.update-version.outputs.version }} (Beta)
|
||||
body: |
|
||||
## Beta Release v${{ needs.create-tag.outputs.version }}
|
||||
## Beta Release v${{ needs.update-version.outputs.version }}
|
||||
|
||||
This is a **beta release** for testing new features. It may contain bugs or incomplete functionality.
|
||||
|
||||
@@ -388,7 +358,7 @@ jobs:
|
||||
|
||||
---
|
||||
|
||||
**Full Changelog**: https://github.com/${{ github.repository }}/compare/main...v${{ needs.create-tag.outputs.version }}
|
||||
**Full Changelog**: https://github.com/${{ github.repository }}/compare/main...v${{ needs.update-version.outputs.version }}
|
||||
files: release-assets/*
|
||||
draft: false
|
||||
prerelease: true
|
||||
@@ -396,7 +366,7 @@ jobs:
|
||||
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
|
||||
dry-run-summary:
|
||||
needs: [create-tag, build-macos-intel, build-macos-arm64, build-windows, build-linux]
|
||||
needs: [update-version, build-macos-intel, build-macos-arm64, build-windows, build-linux]
|
||||
runs-on: ubuntu-latest
|
||||
if: ${{ github.event.inputs.dry_run == 'true' }}
|
||||
steps:
|
||||
@@ -409,7 +379,7 @@ jobs:
|
||||
run: |
|
||||
echo "## Beta Release Dry Run Complete" >> $GITHUB_STEP_SUMMARY
|
||||
echo "" >> $GITHUB_STEP_SUMMARY
|
||||
echo "**Version:** ${{ needs.create-tag.outputs.version }}" >> $GITHUB_STEP_SUMMARY
|
||||
echo "**Version:** ${{ needs.update-version.outputs.version }}" >> $GITHUB_STEP_SUMMARY
|
||||
echo "" >> $GITHUB_STEP_SUMMARY
|
||||
echo "Build artifacts created successfully:" >> $GITHUB_STEP_SUMMARY
|
||||
echo "\`\`\`" >> $GITHUB_STEP_SUMMARY
|
||||
|
||||
@@ -6,14 +6,6 @@ on:
|
||||
pull_request:
|
||||
branches: [main, develop]
|
||||
|
||||
concurrency:
|
||||
group: ci-${{ github.event.pull_request.number || github.ref }}
|
||||
cancel-in-progress: true
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
actions: read
|
||||
|
||||
jobs:
|
||||
# Python tests
|
||||
test-python:
|
||||
@@ -58,7 +50,7 @@ jobs:
|
||||
PYTHONPATH: ${{ github.workspace }}/apps/backend
|
||||
run: |
|
||||
source .venv/bin/activate
|
||||
pytest ../../tests/ -v --cov=. --cov-report=xml --cov-report=term-missing --cov-fail-under=20
|
||||
pytest ../../tests/ -v --cov=. --cov-report=xml --cov-report=term-missing
|
||||
|
||||
- name: Upload coverage reports
|
||||
if: matrix.python-version == '3.12'
|
||||
|
||||
@@ -6,10 +6,6 @@ on:
|
||||
pull_request:
|
||||
branches: [main, develop]
|
||||
|
||||
concurrency:
|
||||
group: lint-${{ github.event.pull_request.number || github.ref }}
|
||||
cancel-in-progress: true
|
||||
|
||||
jobs:
|
||||
# Python linting
|
||||
python:
|
||||
@@ -23,12 +19,35 @@ jobs:
|
||||
with:
|
||||
python-version: '3.12'
|
||||
|
||||
# Pin ruff version to match .pre-commit-config.yaml (astral-sh/ruff-pre-commit rev)
|
||||
- name: Install ruff
|
||||
run: pip install ruff==0.14.10
|
||||
run: pip install ruff
|
||||
|
||||
- name: Run ruff check
|
||||
run: ruff check apps/backend/ --output-format=github
|
||||
|
||||
- name: Run ruff format check
|
||||
run: ruff format apps/backend/ --check --diff
|
||||
|
||||
# TypeScript/React linting
|
||||
frontend:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v4
|
||||
|
||||
- name: Setup Node.js
|
||||
uses: actions/setup-node@v4
|
||||
with:
|
||||
node-version: '24'
|
||||
|
||||
- name: Install dependencies
|
||||
working-directory: apps/frontend
|
||||
run: npm ci --ignore-scripts
|
||||
|
||||
- name: Run ESLint
|
||||
working-directory: apps/frontend
|
||||
run: npm run lint
|
||||
|
||||
- name: Run TypeScript check
|
||||
working-directory: apps/frontend
|
||||
run: npm run typecheck
|
||||
|
||||
@@ -1,227 +0,0 @@
|
||||
name: PR Auto Label
|
||||
|
||||
on:
|
||||
pull_request:
|
||||
types: [opened, synchronize, reopened]
|
||||
|
||||
# Cancel in-progress runs for the same PR
|
||||
concurrency:
|
||||
group: pr-auto-label-${{ github.event.pull_request.number }}
|
||||
cancel-in-progress: true
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
pull-requests: write
|
||||
|
||||
jobs:
|
||||
label:
|
||||
name: Auto Label PR
|
||||
runs-on: ubuntu-latest
|
||||
# Don't run on fork PRs (they can't write labels)
|
||||
if: github.event.pull_request.head.repo.full_name == github.repository
|
||||
timeout-minutes: 5
|
||||
steps:
|
||||
- name: Auto-label PR
|
||||
uses: actions/github-script@v7
|
||||
with:
|
||||
retries: 3
|
||||
retry-exempt-status-codes: 400,401,403,404,422
|
||||
script: |
|
||||
const { owner, repo } = context.repo;
|
||||
const pr = context.payload.pull_request;
|
||||
const prNumber = pr.number;
|
||||
const title = pr.title;
|
||||
|
||||
console.log(`::group::PR #${prNumber} - Auto-labeling`);
|
||||
console.log(`Title: ${title}`);
|
||||
|
||||
const labelsToAdd = new Set();
|
||||
const labelsToRemove = new Set();
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// TYPE LABELS (from PR title - Conventional Commits)
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
const typeMap = {
|
||||
'feat': 'feature',
|
||||
'fix': 'bug',
|
||||
'docs': 'documentation',
|
||||
'refactor': 'refactor',
|
||||
'test': 'test',
|
||||
'ci': 'ci',
|
||||
'chore': 'chore',
|
||||
'perf': 'performance',
|
||||
'style': 'style',
|
||||
'build': 'build'
|
||||
};
|
||||
|
||||
const typeMatch = title.match(/^(\w+)(\(.+?\))?(!)?:/);
|
||||
if (typeMatch) {
|
||||
const type = typeMatch[1].toLowerCase();
|
||||
const isBreaking = typeMatch[3] === '!';
|
||||
|
||||
if (typeMap[type]) {
|
||||
labelsToAdd.add(typeMap[type]);
|
||||
console.log(` 📝 Type: ${type} → ${typeMap[type]}`);
|
||||
}
|
||||
|
||||
if (isBreaking) {
|
||||
labelsToAdd.add('breaking-change');
|
||||
console.log(` ⚠️ Breaking change detected`);
|
||||
}
|
||||
} else {
|
||||
console.log(` ⚠️ No conventional commit prefix found in title`);
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// AREA LABELS (from changed files)
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
let files = [];
|
||||
try {
|
||||
const { data } = await github.rest.pulls.listFiles({
|
||||
owner,
|
||||
repo,
|
||||
pull_number: prNumber,
|
||||
per_page: 100
|
||||
});
|
||||
files = data;
|
||||
} catch (e) {
|
||||
console.log(` ⚠️ Could not fetch files: ${e.message}`);
|
||||
}
|
||||
|
||||
const areas = {
|
||||
frontend: false,
|
||||
backend: false,
|
||||
ci: false,
|
||||
docs: false,
|
||||
tests: false
|
||||
};
|
||||
|
||||
for (const file of files) {
|
||||
const path = file.filename;
|
||||
if (path.startsWith('apps/frontend/')) areas.frontend = true;
|
||||
if (path.startsWith('apps/backend/')) areas.backend = true;
|
||||
if (path.startsWith('.github/')) areas.ci = true;
|
||||
if (path.endsWith('.md') || path.startsWith('docs/')) areas.docs = true;
|
||||
if (path.startsWith('tests/') || path.includes('.test.') || path.includes('.spec.')) areas.tests = true;
|
||||
}
|
||||
|
||||
// Determine area label (mutually exclusive)
|
||||
const areaLabels = ['area/frontend', 'area/backend', 'area/fullstack', 'area/ci'];
|
||||
|
||||
if (areas.frontend && areas.backend) {
|
||||
labelsToAdd.add('area/fullstack');
|
||||
areaLabels.filter(l => l !== 'area/fullstack').forEach(l => labelsToRemove.add(l));
|
||||
console.log(` 📁 Area: fullstack (${files.length} files)`);
|
||||
} else if (areas.frontend) {
|
||||
labelsToAdd.add('area/frontend');
|
||||
areaLabels.filter(l => l !== 'area/frontend').forEach(l => labelsToRemove.add(l));
|
||||
console.log(` 📁 Area: frontend (${files.length} files)`);
|
||||
} else if (areas.backend) {
|
||||
labelsToAdd.add('area/backend');
|
||||
areaLabels.filter(l => l !== 'area/backend').forEach(l => labelsToRemove.add(l));
|
||||
console.log(` 📁 Area: backend (${files.length} files)`);
|
||||
} else if (areas.ci) {
|
||||
labelsToAdd.add('area/ci');
|
||||
areaLabels.filter(l => l !== 'area/ci').forEach(l => labelsToRemove.add(l));
|
||||
console.log(` 📁 Area: ci (${files.length} files)`);
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// SIZE LABELS (from lines changed)
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
const additions = pr.additions || 0;
|
||||
const deletions = pr.deletions || 0;
|
||||
const totalLines = additions + deletions;
|
||||
|
||||
const sizeLabels = ['size/XS', 'size/S', 'size/M', 'size/L', 'size/XL'];
|
||||
let sizeLabel;
|
||||
|
||||
if (totalLines < 10) sizeLabel = 'size/XS';
|
||||
else if (totalLines < 100) sizeLabel = 'size/S';
|
||||
else if (totalLines < 500) sizeLabel = 'size/M';
|
||||
else if (totalLines < 1000) sizeLabel = 'size/L';
|
||||
else sizeLabel = 'size/XL';
|
||||
|
||||
labelsToAdd.add(sizeLabel);
|
||||
sizeLabels.filter(l => l !== sizeLabel).forEach(l => labelsToRemove.add(l));
|
||||
console.log(` 📏 Size: ${sizeLabel} (+${additions}/-${deletions} = ${totalLines} lines)`);
|
||||
|
||||
console.log('::endgroup::');
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
// APPLY LABELS
|
||||
// ═══════════════════════════════════════════════════════════════
|
||||
console.log(`::group::Applying labels`);
|
||||
|
||||
// Remove old labels (in parallel)
|
||||
const removeArray = [...labelsToRemove].filter(l => !labelsToAdd.has(l));
|
||||
if (removeArray.length > 0) {
|
||||
const removePromises = removeArray.map(async (label) => {
|
||||
try {
|
||||
await github.rest.issues.removeLabel({
|
||||
owner,
|
||||
repo,
|
||||
issue_number: prNumber,
|
||||
name: label
|
||||
});
|
||||
console.log(` ✓ Removed: ${label}`);
|
||||
} catch (e) {
|
||||
if (e.status !== 404) {
|
||||
console.log(` ⚠ Could not remove ${label}: ${e.message}`);
|
||||
}
|
||||
}
|
||||
});
|
||||
await Promise.all(removePromises);
|
||||
}
|
||||
|
||||
// Add new labels
|
||||
const addArray = [...labelsToAdd];
|
||||
if (addArray.length > 0) {
|
||||
try {
|
||||
await github.rest.issues.addLabels({
|
||||
owner,
|
||||
repo,
|
||||
issue_number: prNumber,
|
||||
labels: addArray
|
||||
});
|
||||
console.log(` ✓ Added: ${addArray.join(', ')}`);
|
||||
} catch (e) {
|
||||
// Some labels might not exist
|
||||
if (e.status === 404) {
|
||||
core.warning(`Some labels do not exist. Please create them in repository settings.`);
|
||||
// Try adding one by one
|
||||
for (const label of addArray) {
|
||||
try {
|
||||
await github.rest.issues.addLabels({
|
||||
owner,
|
||||
repo,
|
||||
issue_number: prNumber,
|
||||
labels: [label]
|
||||
});
|
||||
} catch (e2) {
|
||||
console.log(` ⚠ Label '${label}' does not exist`);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
console.log('::endgroup::');
|
||||
|
||||
// Summary
|
||||
console.log(`✅ PR #${prNumber} labeled: ${addArray.join(', ')}`);
|
||||
|
||||
// Write job summary
|
||||
core.summary
|
||||
.addHeading(`PR #${prNumber} Auto-Labels`, 3)
|
||||
.addTable([
|
||||
[{data: 'Category', header: true}, {data: 'Label', header: true}],
|
||||
['Type', typeMatch ? typeMap[typeMatch[1].toLowerCase()] || 'none' : 'none'],
|
||||
['Area', areas.frontend && areas.backend ? 'fullstack' : areas.frontend ? 'frontend' : areas.backend ? 'backend' : 'other'],
|
||||
['Size', sizeLabel]
|
||||
])
|
||||
.addRaw(`\n**Files changed:** ${files.length}\n`)
|
||||
.addRaw(`**Lines:** +${additions} / -${deletions}\n`);
|
||||
await core.summary.write();
|
||||
@@ -1,72 +0,0 @@
|
||||
name: PR Status Check
|
||||
|
||||
on:
|
||||
pull_request:
|
||||
types: [opened, synchronize, reopened]
|
||||
|
||||
# Cancel in-progress runs for the same PR
|
||||
concurrency:
|
||||
group: pr-status-${{ github.event.pull_request.number }}
|
||||
cancel-in-progress: true
|
||||
|
||||
permissions:
|
||||
pull-requests: write
|
||||
|
||||
jobs:
|
||||
mark-checking:
|
||||
name: Set Checking Status
|
||||
runs-on: ubuntu-latest
|
||||
# Don't run on fork PRs (they can't write labels)
|
||||
if: github.event.pull_request.head.repo.full_name == github.repository
|
||||
timeout-minutes: 5
|
||||
steps:
|
||||
- name: Update PR status label
|
||||
uses: actions/github-script@v7
|
||||
with:
|
||||
retries: 3
|
||||
retry-exempt-status-codes: 400,401,403,404,422
|
||||
script: |
|
||||
const { owner, repo } = context.repo;
|
||||
const prNumber = context.payload.pull_request.number;
|
||||
const statusLabels = ['🔄 Checking', '✅ Ready for Review', '❌ Checks Failed'];
|
||||
|
||||
console.log(`::group::PR #${prNumber} - Setting status to Checking`);
|
||||
|
||||
// Remove old status labels (parallel for speed)
|
||||
const removePromises = statusLabels.map(async (label) => {
|
||||
try {
|
||||
await github.rest.issues.removeLabel({
|
||||
owner,
|
||||
repo,
|
||||
issue_number: prNumber,
|
||||
name: label
|
||||
});
|
||||
console.log(` ✓ Removed: ${label}`);
|
||||
} catch (e) {
|
||||
if (e.status !== 404) {
|
||||
console.log(` ⚠ Could not remove ${label}: ${e.message}`);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
await Promise.all(removePromises);
|
||||
|
||||
// Add checking label
|
||||
try {
|
||||
await github.rest.issues.addLabels({
|
||||
owner,
|
||||
repo,
|
||||
issue_number: prNumber,
|
||||
labels: ['🔄 Checking']
|
||||
});
|
||||
console.log(` ✓ Added: 🔄 Checking`);
|
||||
} catch (e) {
|
||||
// Label might not exist - create helpful error
|
||||
if (e.status === 404) {
|
||||
core.warning(`Label '🔄 Checking' does not exist. Please create it in repository settings.`);
|
||||
}
|
||||
throw e;
|
||||
}
|
||||
|
||||
console.log('::endgroup::');
|
||||
console.log(`✅ PR #${prNumber} marked as checking`);
|
||||
@@ -1,195 +0,0 @@
|
||||
name: PR Status Gate
|
||||
|
||||
on:
|
||||
workflow_run:
|
||||
workflows: [CI, Lint, Quality Security, CLA Assistant, Quality Commit Lint]
|
||||
types: [completed]
|
||||
|
||||
permissions:
|
||||
pull-requests: write
|
||||
checks: read
|
||||
|
||||
jobs:
|
||||
update-status:
|
||||
name: Update PR Status
|
||||
runs-on: ubuntu-latest
|
||||
# Only run if this workflow_run is associated with a PR
|
||||
if: github.event.workflow_run.pull_requests[0] != null
|
||||
timeout-minutes: 5
|
||||
steps:
|
||||
- name: Check all required checks and update label
|
||||
uses: actions/github-script@v7
|
||||
with:
|
||||
retries: 3
|
||||
retry-exempt-status-codes: 400,401,403,404,422
|
||||
script: |
|
||||
const { owner, repo } = context.repo;
|
||||
const prNumber = context.payload.workflow_run.pull_requests[0].number;
|
||||
const headSha = context.payload.workflow_run.head_sha;
|
||||
const triggerWorkflow = context.payload.workflow_run.name;
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════
|
||||
// REQUIRED CHECK RUNS - Job-level checks (not workflow-level)
|
||||
// ═══════════════════════════════════════════════════════════════════════
|
||||
// Format: "{Workflow Name} / {Job Name} (pull_request)"
|
||||
//
|
||||
// To find check names: Go to PR → Checks tab → copy exact name
|
||||
// To update: Edit this list when workflow jobs are added/renamed/removed
|
||||
//
|
||||
// Last validated: 2025-12-26
|
||||
// ═══════════════════════════════════════════════════════════════════════
|
||||
const requiredChecks = [
|
||||
// CI workflow (ci.yml) - 3 checks
|
||||
'CI / test-frontend (pull_request)',
|
||||
'CI / test-python (3.12) (pull_request)',
|
||||
'CI / test-python (3.13) (pull_request)',
|
||||
// Lint workflow (lint.yml) - 1 check
|
||||
'Lint / python (pull_request)',
|
||||
// Quality Security workflow (quality-security.yml) - 4 checks
|
||||
'Quality Security / CodeQL (javascript-typescript) (pull_request)',
|
||||
'Quality Security / CodeQL (python) (pull_request)',
|
||||
'Quality Security / Python Security (Bandit) (pull_request)',
|
||||
'Quality Security / Security Summary (pull_request)',
|
||||
// CLA Assistant workflow (cla.yml) - 1 check
|
||||
'CLA Assistant / CLA Check',
|
||||
// Quality Commit Lint workflow (quality-commit-lint.yml) - 1 check
|
||||
'Quality Commit Lint / Conventional Commits (pull_request)'
|
||||
];
|
||||
|
||||
const statusLabels = {
|
||||
checking: '🔄 Checking',
|
||||
passed: '✅ Ready for Review',
|
||||
failed: '❌ Checks Failed'
|
||||
};
|
||||
|
||||
console.log(`::group::PR #${prNumber} - Checking required checks`);
|
||||
console.log(`Triggered by: ${triggerWorkflow}`);
|
||||
console.log(`Head SHA: ${headSha}`);
|
||||
console.log(`Required checks: ${requiredChecks.length}`);
|
||||
console.log('');
|
||||
|
||||
// Fetch all check runs for this commit
|
||||
let allCheckRuns = [];
|
||||
try {
|
||||
const { data } = await github.rest.checks.listForRef({
|
||||
owner,
|
||||
repo,
|
||||
ref: headSha,
|
||||
per_page: 100
|
||||
});
|
||||
allCheckRuns = data.check_runs;
|
||||
console.log(`Found ${allCheckRuns.length} total check runs`);
|
||||
} catch (error) {
|
||||
// Add warning annotation so maintainers are alerted
|
||||
core.warning(`Failed to fetch check runs for PR #${prNumber}: ${error.message}. PR label may be outdated.`);
|
||||
console.log(`::error::Failed to fetch check runs: ${error.message}`);
|
||||
console.log('::endgroup::');
|
||||
return;
|
||||
}
|
||||
|
||||
let allComplete = true;
|
||||
let anyFailed = false;
|
||||
const results = [];
|
||||
|
||||
// Check each required check
|
||||
for (const checkName of requiredChecks) {
|
||||
const check = allCheckRuns.find(c => c.name === checkName);
|
||||
|
||||
if (!check) {
|
||||
results.push({ name: checkName, status: '⏳ Pending', complete: false });
|
||||
allComplete = false;
|
||||
} else if (check.status !== 'completed') {
|
||||
results.push({ name: checkName, status: '🔄 Running', complete: false });
|
||||
allComplete = false;
|
||||
} else if (check.conclusion === 'success') {
|
||||
results.push({ name: checkName, status: '✅ Passed', complete: true });
|
||||
} else if (check.conclusion === 'skipped') {
|
||||
// Skipped checks are treated as passed (e.g., path filters, conditional jobs)
|
||||
results.push({ name: checkName, status: '⏭️ Skipped', complete: true, skipped: true });
|
||||
} else {
|
||||
results.push({ name: checkName, status: '❌ Failed', complete: true, failed: true });
|
||||
anyFailed = true;
|
||||
}
|
||||
}
|
||||
|
||||
// Print results table
|
||||
console.log('');
|
||||
console.log('Check Status:');
|
||||
console.log('─'.repeat(70));
|
||||
for (const r of results) {
|
||||
const shortName = r.name.length > 55 ? r.name.substring(0, 52) + '...' : r.name;
|
||||
console.log(` ${r.status.padEnd(12)} ${shortName}`);
|
||||
}
|
||||
console.log('─'.repeat(70));
|
||||
console.log('::endgroup::');
|
||||
|
||||
// Only update label if all required checks are complete
|
||||
if (!allComplete) {
|
||||
const pending = results.filter(r => !r.complete).length;
|
||||
console.log(`⏳ ${pending}/${requiredChecks.length} checks still pending - keeping current label`);
|
||||
return;
|
||||
}
|
||||
|
||||
// Determine final label
|
||||
const newLabel = anyFailed ? statusLabels.failed : statusLabels.passed;
|
||||
|
||||
console.log(`::group::Updating PR #${prNumber} label`);
|
||||
|
||||
// Remove old status labels
|
||||
for (const label of Object.values(statusLabels)) {
|
||||
try {
|
||||
await github.rest.issues.removeLabel({
|
||||
owner,
|
||||
repo,
|
||||
issue_number: prNumber,
|
||||
name: label
|
||||
});
|
||||
console.log(` ✓ Removed: ${label}`);
|
||||
} catch (e) {
|
||||
if (e.status !== 404) {
|
||||
console.log(` ⚠ Could not remove ${label}: ${e.message}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Add final status label
|
||||
try {
|
||||
await github.rest.issues.addLabels({
|
||||
owner,
|
||||
repo,
|
||||
issue_number: prNumber,
|
||||
labels: [newLabel]
|
||||
});
|
||||
console.log(` ✓ Added: ${newLabel}`);
|
||||
} catch (e) {
|
||||
if (e.status === 404) {
|
||||
core.warning(`Label '${newLabel}' does not exist. Please create it in repository settings.`);
|
||||
}
|
||||
throw e;
|
||||
}
|
||||
|
||||
console.log('::endgroup::');
|
||||
|
||||
// Summary
|
||||
const passedCount = results.filter(r => r.status === '✅ Passed').length;
|
||||
const skippedCount = results.filter(r => r.skipped).length;
|
||||
const failedCount = results.filter(r => r.failed).length;
|
||||
|
||||
if (anyFailed) {
|
||||
console.log(`❌ PR #${prNumber} has ${failedCount} failing check(s)`);
|
||||
core.summary.addRaw(`## ❌ PR #${prNumber} - Checks Failed\n\n`);
|
||||
core.summary.addRaw(`**${failedCount}** of **${requiredChecks.length}** required checks failed.\n\n`);
|
||||
} else {
|
||||
const skippedNote = skippedCount > 0 ? ` (${skippedCount} skipped)` : '';
|
||||
const totalSuccessful = passedCount + skippedCount;
|
||||
console.log(`✅ PR #${prNumber} is ready for review (${totalSuccessful}/${requiredChecks.length} checks succeeded${skippedNote})`);
|
||||
core.summary.addRaw(`## ✅ PR #${prNumber} - Ready for Review\n\n`);
|
||||
core.summary.addRaw(`All **${requiredChecks.length}** required checks succeeded${skippedNote}.\n\n`);
|
||||
}
|
||||
|
||||
// Add results to summary
|
||||
core.summary.addTable([
|
||||
[{data: 'Check', header: true}, {data: 'Status', header: true}],
|
||||
...results.map(r => [r.name, r.status])
|
||||
]);
|
||||
await core.summary.write();
|
||||
@@ -1,115 +0,0 @@
|
||||
name: Quality Commit Lint
|
||||
|
||||
on:
|
||||
pull_request:
|
||||
branches: [main, develop]
|
||||
types: [opened, edited, synchronize, reopened]
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
pull-requests: read
|
||||
|
||||
jobs:
|
||||
check:
|
||||
name: Conventional Commits
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 5
|
||||
steps:
|
||||
- name: Validate PR title
|
||||
uses: actions/github-script@v7
|
||||
with:
|
||||
retries: 3
|
||||
script: |
|
||||
const pr = context.payload.pull_request;
|
||||
const title = pr.title;
|
||||
// Sanitize title for safe markdown interpolation (prevent injection)
|
||||
const sanitizedTitle = title.replace(/`/g, "'").replace(/\[/g, '\\[').replace(/\]/g, '\\]');
|
||||
|
||||
console.log(`::group::PR #${pr.number} - Validating PR title`);
|
||||
console.log(`Title: ${title}`);
|
||||
|
||||
// Conventional Commits pattern for PR title
|
||||
// type(scope)?: description (max 100 chars)
|
||||
// Optional ! for breaking changes: feat!: or feat(scope)!:
|
||||
// Scope allows: letters, numbers, hyphens, underscores, slashes, dots
|
||||
const pattern = /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\([a-zA-Z0-9_\-\/\.]+\))?!?: .{1,100}$/;
|
||||
|
||||
const isValid = pattern.test(title);
|
||||
console.log(`Valid: ${isValid}`);
|
||||
console.log('::endgroup::');
|
||||
|
||||
if (!isValid) {
|
||||
// Log helpful error message to console (visible in workflow logs)
|
||||
console.log('');
|
||||
console.log('❌ PR title does not follow Conventional Commits format');
|
||||
console.log('');
|
||||
console.log('Expected format: type(scope): description');
|
||||
console.log('');
|
||||
console.log('Valid types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert');
|
||||
console.log('');
|
||||
console.log('Examples of valid PR titles:');
|
||||
console.log(' ✓ feat(auth): add OAuth2 login support');
|
||||
console.log(' ✓ fix(api): handle null response correctly');
|
||||
console.log(' ✓ docs: update README installation steps');
|
||||
console.log(' ✓ chore: update dependencies');
|
||||
console.log('');
|
||||
console.log(`Your title: "${title}"`);
|
||||
console.log('');
|
||||
console.log('Suggested fix for your title:');
|
||||
// Try to suggest a fix based on the title
|
||||
const lowerTitle = title.toLowerCase();
|
||||
const placeholder = '[add description here]';
|
||||
if (lowerTitle.includes('fix') || lowerTitle.includes('bug')) {
|
||||
const cleaned = title.replace(/^(fix(ed|es|ing)?|bug)[:\s]*/i, '').trim();
|
||||
console.log(` → fix: ${cleaned || placeholder}`);
|
||||
} else if (lowerTitle.includes('add') || lowerTitle.includes('new') || lowerTitle.includes('feature')) {
|
||||
const cleaned = title.replace(/^(add(ed|s|ing)?|new|features?)[:\s]*/i, '').trim();
|
||||
console.log(` → feat: ${cleaned || placeholder}`);
|
||||
} else if (lowerTitle.includes('update') || lowerTitle.includes('change')) {
|
||||
const cleaned = title.replace(/^(update[ds]?|chang(ed|es|ing)?)[:\s]*/i, '').trim();
|
||||
console.log(` → chore: ${cleaned || placeholder}`);
|
||||
} else if (lowerTitle.includes('doc') || lowerTitle.includes('readme')) {
|
||||
const cleaned = title.replace(/^(docs?|readme)[:\s]*/i, '').trim();
|
||||
console.log(` → docs: ${cleaned || placeholder}`);
|
||||
} else {
|
||||
console.log(` → feat: ${title}`);
|
||||
console.log(` → fix: ${title}`);
|
||||
console.log(` → chore: ${title}`);
|
||||
}
|
||||
console.log('');
|
||||
|
||||
let errorMsg = '## ❌ PR Title Validation Failed\n\n';
|
||||
errorMsg += `Your PR title does not follow [Conventional Commits](https://www.conventionalcommits.org/) format:\n\n`;
|
||||
errorMsg += `> \`${sanitizedTitle}\`\n\n`;
|
||||
errorMsg += '### Expected Format\n\n';
|
||||
errorMsg += '```\ntype(scope): description\n```\n\n';
|
||||
errorMsg += '| Type | Description |\n';
|
||||
errorMsg += '|------|-------------|\n';
|
||||
errorMsg += '| `feat` | New feature |\n';
|
||||
errorMsg += '| `fix` | Bug fix |\n';
|
||||
errorMsg += '| `docs` | Documentation only |\n';
|
||||
errorMsg += '| `style` | Code style (formatting, etc.) |\n';
|
||||
errorMsg += '| `refactor` | Code refactoring |\n';
|
||||
errorMsg += '| `perf` | Performance improvement |\n';
|
||||
errorMsg += '| `test` | Adding/updating tests |\n';
|
||||
errorMsg += '| `build` | Build system changes |\n';
|
||||
errorMsg += '| `ci` | CI/CD changes |\n';
|
||||
errorMsg += '| `chore` | Maintenance tasks |\n';
|
||||
errorMsg += '| `revert` | Reverting changes |\n\n';
|
||||
errorMsg += '### Examples\n\n';
|
||||
errorMsg += '```\nfeat(auth): add OAuth2 login support\nfix(api/users): handle null response correctly\nfix(package.json): update dependencies\ndocs: update README installation steps\nci: add automated release workflow\n```\n\n';
|
||||
errorMsg += '### How to Fix\n\n';
|
||||
errorMsg += 'Edit your PR title to follow the format above.\n';
|
||||
|
||||
core.summary.addRaw(errorMsg);
|
||||
await core.summary.write();
|
||||
|
||||
core.setFailed('PR title does not follow Conventional Commits format');
|
||||
} else {
|
||||
console.log(`✅ PR title follows Conventional Commits format`);
|
||||
|
||||
core.summary
|
||||
.addHeading('✅ PR Title Valid', 3)
|
||||
.addRaw(`PR title follows Conventional Commits format: \`${sanitizedTitle}\``);
|
||||
await core.summary.write();
|
||||
}
|
||||
@@ -1,178 +0,0 @@
|
||||
name: Quality Security
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [main, develop]
|
||||
pull_request:
|
||||
branches: [main, develop]
|
||||
schedule:
|
||||
- cron: '0 0 * * 1' # Weekly on Monday at midnight UTC
|
||||
|
||||
# Cancel in-progress runs for the same branch/PR
|
||||
concurrency:
|
||||
group: security-${{ github.workflow }}-${{ github.ref }}
|
||||
cancel-in-progress: true
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
security-events: write
|
||||
actions: read
|
||||
|
||||
jobs:
|
||||
codeql:
|
||||
name: CodeQL (${{ matrix.language }})
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 30
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
language: [python, javascript-typescript]
|
||||
steps:
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v4
|
||||
|
||||
- name: Initialize CodeQL
|
||||
uses: github/codeql-action/init@v3
|
||||
with:
|
||||
languages: ${{ matrix.language }}
|
||||
queries: +security-extended,security-and-quality
|
||||
|
||||
- name: Autobuild
|
||||
uses: github/codeql-action/autobuild@v3
|
||||
|
||||
- name: Perform CodeQL Analysis
|
||||
uses: github/codeql-action/analyze@v3
|
||||
with:
|
||||
category: "/language:${{ matrix.language }}"
|
||||
|
||||
python-security:
|
||||
name: Python Security (Bandit)
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 10
|
||||
steps:
|
||||
- name: Checkout
|
||||
uses: actions/checkout@v4
|
||||
|
||||
- name: Set up Python
|
||||
uses: actions/setup-python@v5
|
||||
with:
|
||||
python-version: '3.12'
|
||||
|
||||
- name: Install Bandit
|
||||
run: pip install bandit
|
||||
|
||||
- name: Run Bandit security scan
|
||||
id: bandit
|
||||
run: |
|
||||
echo "::group::Running Bandit security scan"
|
||||
# Run Bandit; exit code 1 means issues found (expected), other codes are errors
|
||||
# Flags: -r=recursive, -ll=severity LOW+, -ii=confidence LOW+, -f=format, -o=output
|
||||
bandit -r apps/backend/ -ll -ii -f json -o bandit-report.json || BANDIT_EXIT=$?
|
||||
if [ "${BANDIT_EXIT:-0}" -gt 1 ]; then
|
||||
echo "::error::Bandit scan failed with exit code $BANDIT_EXIT"
|
||||
exit 1
|
||||
fi
|
||||
echo "::endgroup::"
|
||||
|
||||
- name: Analyze Bandit results
|
||||
uses: actions/github-script@v7
|
||||
with:
|
||||
script: |
|
||||
const fs = require('fs');
|
||||
|
||||
// Check if report exists
|
||||
if (!fs.existsSync('bandit-report.json')) {
|
||||
core.setFailed('Bandit report not found - scan may have failed');
|
||||
return;
|
||||
}
|
||||
|
||||
const report = JSON.parse(fs.readFileSync('bandit-report.json', 'utf8'));
|
||||
const results = report.results || [];
|
||||
|
||||
// Categorize by severity
|
||||
const high = results.filter(r => r.issue_severity === 'HIGH');
|
||||
const medium = results.filter(r => r.issue_severity === 'MEDIUM');
|
||||
const low = results.filter(r => r.issue_severity === 'LOW');
|
||||
|
||||
console.log(`::group::Bandit Security Scan Results`);
|
||||
console.log(`Found ${results.length} issues:`);
|
||||
console.log(` 🔴 HIGH: ${high.length}`);
|
||||
console.log(` 🟡 MEDIUM: ${medium.length}`);
|
||||
console.log(` 🟢 LOW: ${low.length}`);
|
||||
console.log('');
|
||||
|
||||
// Print high severity issues
|
||||
if (high.length > 0) {
|
||||
console.log('High Severity Issues:');
|
||||
console.log('─'.repeat(60));
|
||||
for (const issue of high) {
|
||||
console.log(` ${issue.filename}:${issue.line_number}`);
|
||||
console.log(` ${issue.issue_text}`);
|
||||
console.log(` Test: ${issue.test_id} (${issue.test_name})`);
|
||||
console.log('');
|
||||
}
|
||||
}
|
||||
console.log('::endgroup::');
|
||||
|
||||
// Build summary
|
||||
let summary = `## 🔒 Python Security Scan (Bandit)\n\n`;
|
||||
summary += `| Severity | Count |\n`;
|
||||
summary += `|----------|-------|\n`;
|
||||
summary += `| 🔴 High | ${high.length} |\n`;
|
||||
summary += `| 🟡 Medium | ${medium.length} |\n`;
|
||||
summary += `| 🟢 Low | ${low.length} |\n\n`;
|
||||
|
||||
if (high.length > 0) {
|
||||
summary += `### High Severity Issues\n\n`;
|
||||
for (const issue of high) {
|
||||
summary += `- **${issue.filename}:${issue.line_number}**\n`;
|
||||
summary += ` - ${issue.issue_text}\n`;
|
||||
summary += ` - Test: \`${issue.test_id}\` (${issue.test_name})\n\n`;
|
||||
}
|
||||
}
|
||||
|
||||
core.summary.addRaw(summary);
|
||||
await core.summary.write();
|
||||
|
||||
// Fail if high severity issues found
|
||||
if (high.length > 0) {
|
||||
core.setFailed(`Found ${high.length} high severity security issue(s)`);
|
||||
} else {
|
||||
console.log('✅ No high severity security issues found');
|
||||
}
|
||||
|
||||
# Summary job that waits for all security checks
|
||||
security-summary:
|
||||
name: Security Summary
|
||||
runs-on: ubuntu-latest
|
||||
needs: [codeql, python-security]
|
||||
if: always()
|
||||
timeout-minutes: 5
|
||||
steps:
|
||||
- name: Check security results
|
||||
uses: actions/github-script@v7
|
||||
with:
|
||||
script: |
|
||||
const codeql = '${{ needs.codeql.result }}';
|
||||
const bandit = '${{ needs.python-security.result }}';
|
||||
|
||||
console.log('Security Check Results:');
|
||||
console.log(` CodeQL: ${codeql}`);
|
||||
console.log(` Bandit: ${bandit}`);
|
||||
|
||||
// Only 'failure' is a real failure; 'skipped' is acceptable (e.g., path filters)
|
||||
const acceptable = ['success', 'skipped'];
|
||||
const codeqlOk = acceptable.includes(codeql);
|
||||
const banditOk = acceptable.includes(bandit);
|
||||
const allPassed = codeqlOk && banditOk;
|
||||
|
||||
if (allPassed) {
|
||||
console.log('\n✅ All security checks passed');
|
||||
core.summary.addRaw('## ✅ Security Checks Passed\n\nAll security scans completed successfully.');
|
||||
} else {
|
||||
console.log('\n❌ Some security checks failed');
|
||||
core.summary.addRaw('## ❌ Security Checks Failed\n\nOne or more security scans found issues.');
|
||||
core.setFailed('Security checks failed');
|
||||
}
|
||||
|
||||
await core.summary.write();
|
||||
+15
-166
@@ -20,11 +20,6 @@ jobs:
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Setup Python
|
||||
uses: actions/setup-python@v5
|
||||
with:
|
||||
python-version: '3.11'
|
||||
|
||||
- name: Setup Node.js
|
||||
uses: actions/setup-node@v4
|
||||
with:
|
||||
@@ -43,19 +38,11 @@ jobs:
|
||||
- name: Install dependencies
|
||||
run: cd apps/frontend && npm ci
|
||||
|
||||
- name: Cache bundled Python
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
path: apps/frontend/python-runtime
|
||||
key: python-bundle-${{ runner.os }}-x64-3.12.8
|
||||
restore-keys: |
|
||||
python-bundle-${{ runner.os }}-x64-
|
||||
|
||||
- name: Build application
|
||||
run: cd apps/frontend && npm run build
|
||||
|
||||
- name: Package macOS (Intel)
|
||||
run: cd apps/frontend && npm run package:mac -- --x64
|
||||
run: cd apps/frontend && npm run package:mac -- --arch=x64
|
||||
env:
|
||||
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
CSC_LINK: ${{ secrets.MAC_CERTIFICATE }}
|
||||
@@ -97,11 +84,6 @@ jobs:
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Setup Python
|
||||
uses: actions/setup-python@v5
|
||||
with:
|
||||
python-version: '3.11'
|
||||
|
||||
- name: Setup Node.js
|
||||
uses: actions/setup-node@v4
|
||||
with:
|
||||
@@ -120,19 +102,11 @@ jobs:
|
||||
- name: Install dependencies
|
||||
run: cd apps/frontend && npm ci
|
||||
|
||||
- name: Cache bundled Python
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
path: apps/frontend/python-runtime
|
||||
key: python-bundle-${{ runner.os }}-arm64-3.12.8
|
||||
restore-keys: |
|
||||
python-bundle-${{ runner.os }}-arm64-
|
||||
|
||||
- name: Build application
|
||||
run: cd apps/frontend && npm run build
|
||||
|
||||
- name: Package macOS (Apple Silicon)
|
||||
run: cd apps/frontend && npm run package:mac -- --arm64
|
||||
run: cd apps/frontend && npm run package:mac -- --arch=arm64
|
||||
env:
|
||||
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
CSC_LINK: ${{ secrets.MAC_CERTIFICATE }}
|
||||
@@ -173,11 +147,6 @@ jobs:
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Setup Python
|
||||
uses: actions/setup-python@v5
|
||||
with:
|
||||
python-version: '3.11'
|
||||
|
||||
- name: Setup Node.js
|
||||
uses: actions/setup-node@v4
|
||||
with:
|
||||
@@ -197,14 +166,6 @@ jobs:
|
||||
- name: Install dependencies
|
||||
run: cd apps/frontend && npm ci
|
||||
|
||||
- name: Cache bundled Python
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
path: apps/frontend/python-runtime
|
||||
key: python-bundle-${{ runner.os }}-x64-3.12.8
|
||||
restore-keys: |
|
||||
python-bundle-${{ runner.os }}-x64-
|
||||
|
||||
- name: Build application
|
||||
run: cd apps/frontend && npm run build
|
||||
|
||||
@@ -227,11 +188,6 @@ jobs:
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Setup Python
|
||||
uses: actions/setup-python@v5
|
||||
with:
|
||||
python-version: '3.11'
|
||||
|
||||
- name: Setup Node.js
|
||||
uses: actions/setup-node@v4
|
||||
with:
|
||||
@@ -250,22 +206,6 @@ jobs:
|
||||
- name: Install dependencies
|
||||
run: cd apps/frontend && npm ci
|
||||
|
||||
- name: Setup Flatpak
|
||||
run: |
|
||||
sudo apt-get update
|
||||
sudo apt-get install -y flatpak flatpak-builder
|
||||
flatpak remote-add --user --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
|
||||
flatpak install -y --user flathub org.freedesktop.Platform//25.08 org.freedesktop.Sdk//25.08
|
||||
flatpak install -y --user flathub org.electronjs.Electron2.BaseApp//25.08
|
||||
|
||||
- name: Cache bundled Python
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
path: apps/frontend/python-runtime
|
||||
key: python-bundle-${{ runner.os }}-x64-3.12.8
|
||||
restore-keys: |
|
||||
python-bundle-${{ runner.os }}-x64-
|
||||
|
||||
- name: Build application
|
||||
run: cd apps/frontend && npm run build
|
||||
|
||||
@@ -281,7 +221,6 @@ jobs:
|
||||
path: |
|
||||
apps/frontend/dist/*.AppImage
|
||||
apps/frontend/dist/*.deb
|
||||
apps/frontend/dist/*.flatpak
|
||||
|
||||
create-release:
|
||||
needs: [build-macos-intel, build-macos-arm64, build-windows, build-linux]
|
||||
@@ -301,12 +240,12 @@ jobs:
|
||||
- name: Flatten and validate artifacts
|
||||
run: |
|
||||
mkdir -p release-assets
|
||||
find dist -type f \( -name "*.dmg" -o -name "*.zip" -o -name "*.exe" -o -name "*.AppImage" -o -name "*.deb" -o -name "*.flatpak" \) -exec cp {} release-assets/ \;
|
||||
find dist -type f \( -name "*.dmg" -o -name "*.zip" -o -name "*.exe" -o -name "*.AppImage" -o -name "*.deb" \) -exec cp {} release-assets/ \;
|
||||
|
||||
# Validate that at least one artifact was copied
|
||||
artifact_count=$(find release-assets -type f \( -name "*.dmg" -o -name "*.zip" -o -name "*.exe" -o -name "*.AppImage" -o -name "*.deb" -o -name "*.flatpak" \) | wc -l)
|
||||
artifact_count=$(find release-assets -type f \( -name "*.dmg" -o -name "*.zip" -o -name "*.exe" -o -name "*.AppImage" -o -name "*.deb" \) | wc -l)
|
||||
if [ "$artifact_count" -eq 0 ]; then
|
||||
echo "::error::No build artifacts found! Expected .dmg, .zip, .exe, .AppImage, .deb, or .flatpak files."
|
||||
echo "::error::No build artifacts found! Expected .dmg, .zip, .exe, .AppImage, or .deb files."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
@@ -335,7 +274,7 @@ jobs:
|
||||
echo "## VirusTotal Scan Results" > vt_results.md
|
||||
echo "" >> vt_results.md
|
||||
|
||||
for file in release-assets/*.{exe,dmg,AppImage,deb,flatpak}; do
|
||||
for file in release-assets/*.{exe,dmg,AppImage,deb}; do
|
||||
[ -f "$file" ] || continue
|
||||
filename=$(basename "$file")
|
||||
filesize=$(stat -c%s "$file" 2>/dev/null || stat -f%z "$file")
|
||||
@@ -506,116 +445,26 @@ jobs:
|
||||
ref: main
|
||||
token: ${{ secrets.GITHUB_TOKEN }}
|
||||
|
||||
- name: Extract version and detect release type
|
||||
- name: Extract version from tag
|
||||
id: version
|
||||
run: |
|
||||
# Extract version from tag (v2.7.2 -> 2.7.2)
|
||||
VERSION=${GITHUB_REF_NAME#v}
|
||||
echo "version=$VERSION" >> $GITHUB_OUTPUT
|
||||
|
||||
# Detect if this is a prerelease (contains - after version, e.g., 2.7.2-beta.10)
|
||||
if [[ "$VERSION" == *-* ]]; then
|
||||
echo "is_prerelease=true" >> $GITHUB_OUTPUT
|
||||
echo "Detected PRERELEASE: $VERSION"
|
||||
else
|
||||
echo "is_prerelease=false" >> $GITHUB_OUTPUT
|
||||
echo "Detected STABLE release: $VERSION"
|
||||
fi
|
||||
echo "Updating README to version: $VERSION"
|
||||
|
||||
- name: Update README.md
|
||||
run: |
|
||||
python3 << 'EOF'
|
||||
import re
|
||||
import sys
|
||||
VERSION="${{ steps.version.outputs.version }}"
|
||||
|
||||
version = "${{ steps.version.outputs.version }}"
|
||||
is_prerelease = "${{ steps.version.outputs.is_prerelease }}" == "true"
|
||||
# Update version badge: version-X.Y.Z-blue
|
||||
sed -i "s/version-[0-9]*\.[0-9]*\.[0-9]*-blue/version-${VERSION}-blue/g" README.md
|
||||
|
||||
# Shields.io escapes hyphens as --
|
||||
version_badge = version.replace("-", "--")
|
||||
# Update download links: Auto-Claude-X.Y.Z
|
||||
sed -i "s/Auto-Claude-[0-9]*\.[0-9]*\.[0-9]*/Auto-Claude-${VERSION}/g" README.md
|
||||
|
||||
# Read README
|
||||
with open("README.md", "r") as f:
|
||||
content = f.read()
|
||||
|
||||
# Semver pattern: matches X.Y.Z or X.Y.Z-prerelease (e.g., 2.7.2, 2.7.2-beta.10)
|
||||
# Prerelease MUST contain a dot (beta.10, alpha.1, rc.1) to avoid matching platform suffixes (win32, darwin)
|
||||
semver = r'\d+\.\d+\.\d+(?:-[a-zA-Z]+\.[a-zA-Z0-9.]+)?'
|
||||
# Shields.io escaped pattern (hyphens as --)
|
||||
semver_badge = r'\d+\.\d+\.\d+(?:--[a-zA-Z]+\.[a-zA-Z0-9.]+)?'
|
||||
|
||||
def update_section(text, start_marker, end_marker, replacements):
|
||||
"""Update content between markers with given replacements."""
|
||||
pattern = f'({re.escape(start_marker)})(.*?)({re.escape(end_marker)})'
|
||||
def replace_section(match):
|
||||
section = match.group(2)
|
||||
for old_pattern, new_value in replacements:
|
||||
section = re.sub(old_pattern, new_value, section)
|
||||
return match.group(1) + section + match.group(3)
|
||||
return re.sub(pattern, replace_section, text, flags=re.DOTALL)
|
||||
|
||||
if is_prerelease:
|
||||
print(f"Updating BETA section to {version} (badge: {version_badge})")
|
||||
|
||||
# Update beta badge
|
||||
content = re.sub(
|
||||
rf'beta-{semver_badge}-orange',
|
||||
f'beta-{version_badge}-orange',
|
||||
content
|
||||
)
|
||||
|
||||
# Update beta version badge link
|
||||
content = update_section(content,
|
||||
'<!-- BETA_VERSION_BADGE -->', '<!-- BETA_VERSION_BADGE_END -->',
|
||||
[(rf'tag/v{semver}\)', f'tag/v{version})')])
|
||||
|
||||
# Update beta downloads
|
||||
content = update_section(content,
|
||||
'<!-- BETA_DOWNLOADS -->', '<!-- BETA_DOWNLOADS_END -->',
|
||||
[
|
||||
(rf'Auto-Claude-{semver}', f'Auto-Claude-{version}'),
|
||||
(rf'download/v{semver}/', f'download/v{version}/'),
|
||||
])
|
||||
else:
|
||||
print(f"Updating STABLE section to {version} (badge: {version_badge})")
|
||||
|
||||
# Update top version badge
|
||||
content = update_section(content,
|
||||
'<!-- TOP_VERSION_BADGE -->', '<!-- TOP_VERSION_BADGE_END -->',
|
||||
[
|
||||
(rf'version-{semver_badge}-blue', f'version-{version_badge}-blue'),
|
||||
(rf'tag/v{semver}\)', f'tag/v{version})'),
|
||||
])
|
||||
|
||||
# Update stable badge
|
||||
content = re.sub(
|
||||
rf'stable-{semver_badge}-blue',
|
||||
f'stable-{version_badge}-blue',
|
||||
content
|
||||
)
|
||||
|
||||
# Update stable version badge link
|
||||
content = update_section(content,
|
||||
'<!-- STABLE_VERSION_BADGE -->', '<!-- STABLE_VERSION_BADGE_END -->',
|
||||
[(rf'tag/v{semver}\)', f'tag/v{version})')])
|
||||
|
||||
# Update stable downloads
|
||||
content = update_section(content,
|
||||
'<!-- STABLE_DOWNLOADS -->', '<!-- STABLE_DOWNLOADS_END -->',
|
||||
[
|
||||
(rf'Auto-Claude-{semver}', f'Auto-Claude-{version}'),
|
||||
(rf'download/v{semver}/', f'download/v{version}/'),
|
||||
])
|
||||
|
||||
# Write updated README
|
||||
with open("README.md", "w") as f:
|
||||
f.write(content)
|
||||
|
||||
print(f"README.md updated for {version} (prerelease={is_prerelease})")
|
||||
EOF
|
||||
|
||||
echo "--- Verifying update ---"
|
||||
grep -E "(stable-|beta-|version-)[0-9]" README.md | head -5
|
||||
echo "README.md updated to version $VERSION"
|
||||
grep -E "(version-|Auto-Claude-)" README.md | head -10
|
||||
|
||||
- name: Commit and push README update
|
||||
run: |
|
||||
|
||||
@@ -15,7 +15,7 @@ jobs:
|
||||
with:
|
||||
stale-issue-message: |
|
||||
This issue has been inactive for 60 days. It will be closed in 14 days if there's no activity.
|
||||
|
||||
|
||||
- If this is still relevant, please comment or update the issue
|
||||
- If you're working on this, add the `in-progress` label
|
||||
close-issue-message: 'Closed due to inactivity. Feel free to reopen if still relevant.'
|
||||
|
||||
@@ -18,16 +18,16 @@ jobs:
|
||||
repo-token: ${{ secrets.GITHUB_TOKEN }}
|
||||
issue-message: |
|
||||
👋 Thanks for opening your first issue!
|
||||
|
||||
|
||||
A maintainer will triage this soon. In the meantime:
|
||||
- Make sure you've provided all the requested info
|
||||
- Join our [Discord](https://discord.gg/QhRnz9m5HE) for faster help
|
||||
- Join our [Discord](https://discord.gg/KCXaPBr4Dj) for faster help
|
||||
pr-message: |
|
||||
🎉 Thanks for your first PR!
|
||||
|
||||
|
||||
A maintainer will review it soon. Please make sure:
|
||||
- Your branch is synced with `develop`
|
||||
- Your branch is synced with `main`
|
||||
- CI checks pass
|
||||
- You've followed our [contribution guide](https://github.com/AndyMik90/Auto-Claude/blob/develop/CONTRIBUTING.md)
|
||||
|
||||
Welcome to the Auto Claude community!
|
||||
- You've followed our [contribution guide](CONTRIBUTING.md)
|
||||
|
||||
Welcome to the Auto-Claude community!
|
||||
|
||||
@@ -115,7 +115,6 @@ node_modules/
|
||||
dist/
|
||||
out/
|
||||
*.tsbuildinfo
|
||||
apps/frontend/python-runtime/
|
||||
|
||||
# Cache
|
||||
.cache/
|
||||
|
||||
+4
-12
@@ -1,16 +1,12 @@
|
||||
#!/bin/sh
|
||||
|
||||
# Commit message validation
|
||||
# Enforces conventional commit format: type(scope)!?: description
|
||||
# Enforces conventional commit format: type(scope): description
|
||||
#
|
||||
# Valid types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert
|
||||
# Scope allows: letters, numbers, hyphens, underscores, slashes, dots
|
||||
# Optional ! for breaking changes
|
||||
# Examples:
|
||||
# feat(tasks): add drag and drop support
|
||||
# fix(terminal): resolve scroll position issue
|
||||
# feat!: breaking change without scope
|
||||
# feat(api)!: breaking change with scope
|
||||
# docs: update README with setup instructions
|
||||
# chore: update dependencies
|
||||
|
||||
@@ -18,10 +14,8 @@ commit_msg_file=$1
|
||||
commit_msg=$(cat "$commit_msg_file")
|
||||
|
||||
# Regex for conventional commits
|
||||
# Format: type(optional-scope)!?: description
|
||||
# Scope allows: letters, numbers, hyphens, underscores, slashes, dots (consistent with GitHub workflow)
|
||||
# Optional ! for breaking changes: feat!: or feat(scope)!:
|
||||
pattern="^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\([a-zA-Z0-9_/.-]+\))?!?: .{1,100}$"
|
||||
# Format: type(optional-scope): description
|
||||
pattern="^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\([a-z0-9-]+\))?: .{1,100}$"
|
||||
|
||||
# Allow merge commits
|
||||
if echo "$commit_msg" | grep -qE "^Merge "; then
|
||||
@@ -42,7 +36,7 @@ if ! echo "$first_line" | grep -qE "$pattern"; then
|
||||
echo ""
|
||||
echo "Your message: $first_line"
|
||||
echo ""
|
||||
echo "Expected format: type(scope)!?: description"
|
||||
echo "Expected format: type(scope): description"
|
||||
echo ""
|
||||
echo "Valid types:"
|
||||
echo " feat - A new feature"
|
||||
@@ -60,8 +54,6 @@ if ! echo "$first_line" | grep -qE "$pattern"; then
|
||||
echo "Examples:"
|
||||
echo " feat(tasks): add drag and drop support"
|
||||
echo " fix(terminal): resolve scroll position issue"
|
||||
echo " feat!: breaking change without scope"
|
||||
echo " feat(api)!: breaking change with scope"
|
||||
echo " docs: update README"
|
||||
echo " chore: update dependencies"
|
||||
echo ""
|
||||
|
||||
+10
-12
@@ -38,12 +38,10 @@ if git diff --cached --name-only | grep -q "^package.json$"; then
|
||||
|
||||
# Sync to README.md
|
||||
if [ -f "README.md" ]; then
|
||||
# Escape hyphens for shields.io badge format (shields.io uses -- for literal hyphens)
|
||||
ESCAPED_VERSION=$(echo "$VERSION" | sed 's/-/--/g')
|
||||
# Update version badge - match both stable (X.Y.Z) and prerelease (X.Y.Z-prerelease.N or X.Y.Z--prerelease.N)
|
||||
sed -i.bak "s/version-[0-9]*\.[0-9]*\.[0-9]*\(-\{1,2\}[a-z]*\.[0-9]*\)*-blue/version-$ESCAPED_VERSION-blue/g" README.md
|
||||
# Update download links - match both stable and prerelease versions
|
||||
sed -i.bak "s/Auto-Claude-[0-9]*\.[0-9]*\.[0-9]*\(-[a-z]*\.[0-9]*\)*/Auto-Claude-$VERSION/g" README.md
|
||||
# Update version badge
|
||||
sed -i.bak "s/version-[0-9]*\.[0-9]*\.[0-9]*-blue/version-$VERSION-blue/g" README.md
|
||||
# Update download links
|
||||
sed -i.bak "s/Auto-Claude-[0-9]*\.[0-9]*\.[0-9]*/Auto-Claude-$VERSION/g" README.md
|
||||
rm -f README.md.bak
|
||||
git add README.md
|
||||
echo " Updated README.md to $VERSION"
|
||||
@@ -113,7 +111,7 @@ if git diff --cached --name-only | grep -q "^apps/backend/.*\.py$"; then
|
||||
exit 1
|
||||
fi
|
||||
cd ../..
|
||||
|
||||
|
||||
echo "Backend checks passed!"
|
||||
fi
|
||||
|
||||
@@ -125,10 +123,10 @@ fi
|
||||
if git diff --cached --name-only | grep -q "^apps/frontend/"; then
|
||||
echo "Frontend changes detected, running frontend checks..."
|
||||
cd apps/frontend
|
||||
|
||||
|
||||
# Run lint-staged (handles staged .ts/.tsx files)
|
||||
npm exec lint-staged
|
||||
|
||||
|
||||
# Run TypeScript type check
|
||||
echo "Running type check..."
|
||||
npm run typecheck
|
||||
@@ -136,7 +134,7 @@ if git diff --cached --name-only | grep -q "^apps/frontend/"; then
|
||||
echo "Type check failed. Please fix TypeScript errors before committing."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
|
||||
# Run linting
|
||||
echo "Running lint..."
|
||||
npm run lint
|
||||
@@ -144,7 +142,7 @@ if git diff --cached --name-only | grep -q "^apps/frontend/"; then
|
||||
echo "Lint failed. Run 'npm run lint:fix' to auto-fix issues."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
|
||||
# Check for vulnerabilities (only high severity)
|
||||
echo "Checking for vulnerabilities..."
|
||||
npm audit --audit-level=high
|
||||
@@ -152,7 +150,7 @@ if git diff --cached --name-only | grep -q "^apps/frontend/"; then
|
||||
echo "High severity vulnerabilities found. Run 'npm audit fix' to resolve."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
|
||||
cd ../..
|
||||
echo "Frontend checks passed!"
|
||||
fi
|
||||
|
||||
+16
-59
@@ -4,47 +4,26 @@ repos:
|
||||
hooks:
|
||||
- id: version-sync
|
||||
name: Version Sync
|
||||
entry: bash
|
||||
args:
|
||||
- -c
|
||||
- |
|
||||
VERSION=$(node -p "require('./package.json').version")
|
||||
if [ -n "$VERSION" ]; then
|
||||
|
||||
# Sync to apps/frontend/package.json
|
||||
node -e "
|
||||
const fs = require('fs');
|
||||
const p = require('./apps/frontend/package.json');
|
||||
const v = process.argv[1];
|
||||
if (p.version !== v) {
|
||||
p.version = v;
|
||||
fs.writeFileSync('./apps/frontend/package.json', JSON.stringify(p, null, 2) + '\n');
|
||||
}
|
||||
" "$VERSION"
|
||||
|
||||
# Sync to apps/backend/__init__.py
|
||||
sed -i.bak "s/__version__ = \"[^\"]*\"/__version__ = \"$VERSION\"/" apps/backend/__init__.py && rm -f apps/backend/__init__.py.bak
|
||||
|
||||
# Sync to README.md - shields.io version badge (text and URL)
|
||||
ESCAPED_VERSION=$(echo "$VERSION" | sed 's/-/--/g')
|
||||
sed -i.bak -e "s/version-[0-9]*\.[0-9]*\.[0-9]*\(-\{1,2\}[a-z]*\.[0-9]*\)*-blue/version-$ESCAPED_VERSION-blue/g" -e "s|releases/tag/v[0-9.a-z-]*)|releases/tag/v$VERSION)|g" README.md
|
||||
|
||||
# Sync to README.md - download links with correct filenames and URLs
|
||||
for SUFFIX in "win32-x64.exe" "darwin-arm64.dmg" "darwin-x64.dmg" "linux-x86_64.AppImage" "linux-amd64.deb"; do
|
||||
sed -i.bak "s|Auto-Claude-[0-9.a-z-]*-${SUFFIX}](https://github.com/AndyMik90/Auto-Claude/releases/download/v[^/]*/Auto-Claude-[^)]*-${SUFFIX})|Auto-Claude-${VERSION}-${SUFFIX}](https://github.com/AndyMik90/Auto-Claude/releases/download/v${VERSION}/Auto-Claude-${VERSION}-${SUFFIX})|g" README.md
|
||||
done
|
||||
rm -f README.md.bak
|
||||
|
||||
# Stage changes
|
||||
git add apps/frontend/package.json apps/backend/__init__.py README.md 2>/dev/null || true
|
||||
fi
|
||||
entry: bash -c '
|
||||
VERSION=$(node -p "require(\"./package.json\").version");
|
||||
if [ -n "$VERSION" ]; then
|
||||
# Sync to apps/frontend/package.json
|
||||
node -e "const fs=require(\"fs\");const p=require(\"./apps/frontend/package.json\");if(p.version!==\"$VERSION\"){p.version=\"$VERSION\";fs.writeFileSync(\"./apps/frontend/package.json\",JSON.stringify(p,null,2)+\"\n\");}";
|
||||
# Sync to apps/backend/__init__.py
|
||||
sed -i.bak "s/__version__ = \"[^\"]*\"/__version__ = \"$VERSION\"/" apps/backend/__init__.py && rm -f apps/backend/__init__.py.bak;
|
||||
# Sync to README.md
|
||||
sed -i.bak "s/version-[0-9]*\.[0-9]*\.[0-9]*-blue/version-$VERSION-blue/g" README.md;
|
||||
sed -i.bak "s/Auto-Claude-[0-9]*\.[0-9]*\.[0-9]*/Auto-Claude-$VERSION/g" README.md && rm -f README.md.bak;
|
||||
git add apps/frontend/package.json apps/backend/__init__.py README.md 2>/dev/null || true;
|
||||
fi
|
||||
'
|
||||
language: system
|
||||
files: ^package\.json$
|
||||
pass_filenames: false
|
||||
|
||||
# Python linting (apps/backend/)
|
||||
- repo: https://github.com/astral-sh/ruff-pre-commit
|
||||
rev: v0.14.10
|
||||
rev: v0.8.3
|
||||
hooks:
|
||||
- id: ruff
|
||||
args: [--fix]
|
||||
@@ -58,29 +37,7 @@ repos:
|
||||
hooks:
|
||||
- id: pytest
|
||||
name: Python Tests
|
||||
entry: bash
|
||||
args:
|
||||
- -c
|
||||
- |
|
||||
cd apps/backend
|
||||
if [ -f ".venv/bin/pytest" ]; then
|
||||
PYTEST_CMD=".venv/bin/pytest"
|
||||
elif [ -f ".venv/Scripts/pytest.exe" ]; then
|
||||
PYTEST_CMD=".venv/Scripts/pytest.exe"
|
||||
else
|
||||
PYTEST_CMD="python -m pytest"
|
||||
fi
|
||||
PYTHONPATH=. $PYTEST_CMD \
|
||||
../../tests/ \
|
||||
-v \
|
||||
--tb=short \
|
||||
-x \
|
||||
-m "not slow and not integration" \
|
||||
--ignore=../../tests/test_graphiti.py \
|
||||
--ignore=../../tests/test_merge_file_tracker.py \
|
||||
--ignore=../../tests/test_service_orchestrator.py \
|
||||
--ignore=../../tests/test_worktree.py \
|
||||
--ignore=../../tests/test_workspace.py
|
||||
entry: bash -c 'cd apps/backend && PYTHONPATH=. python -m pytest ../../tests/ -v --tb=short -x -m "not slow and not integration" --ignore=../../tests/test_graphiti.py --ignore=../../tests/test_merge_file_tracker.py --ignore=../../tests/test_service_orchestrator.py --ignore=../../tests/test_worktree.py --ignore=../../tests/test_workspace.py'
|
||||
language: system
|
||||
files: ^(apps/backend/.*\.py$|tests/.*\.py$)
|
||||
pass_filenames: false
|
||||
@@ -104,7 +61,7 @@ repos:
|
||||
|
||||
# General checks
|
||||
- repo: https://github.com/pre-commit/pre-commit-hooks
|
||||
rev: v6.0.0
|
||||
rev: v5.0.0
|
||||
hooks:
|
||||
- id: trailing-whitespace
|
||||
- id: end-of-file-fixer
|
||||
|
||||
@@ -1,76 +0,0 @@
|
||||
# Auto Claude Individual Contributor License Agreement
|
||||
|
||||
Thank you for your interest in contributing to Auto Claude. This Contributor License Agreement ("Agreement") documents the rights granted by contributors to the Project.
|
||||
|
||||
By signing this Agreement, you accept and agree to the following terms and conditions for your present and future Contributions submitted to the Project.
|
||||
|
||||
## 1. Definitions
|
||||
|
||||
**"You" (or "Your")** means the individual who submits a Contribution to the Project.
|
||||
|
||||
**"Contribution"** means any original work of authorship, including any modifications or additions to an existing work, that is intentionally submitted by You to the Project for inclusion in, or documentation of, the Project. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Project or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Project for the purpose of discussing and improving the Project.
|
||||
|
||||
**"Project"** means Auto Claude, a multi-agent autonomous coding framework, currently available at https://github.com/AndyMik90/Auto-Claude.
|
||||
|
||||
**"Project Owner"** means Andre Mikalsen and any designated successors or assignees.
|
||||
|
||||
## 2. Grant of Copyright License
|
||||
|
||||
Subject to the terms and conditions of this Agreement, You hereby grant to the Project Owner and to recipients of software distributed by the Project Owner a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to:
|
||||
|
||||
- Reproduce, prepare derivative works of, publicly display, publicly perform, and distribute Your Contributions and such derivative works
|
||||
- Sublicense any or all of the foregoing rights to third parties
|
||||
|
||||
## 3. Grant of Patent License
|
||||
|
||||
Subject to the terms and conditions of this Agreement, You hereby grant to the Project Owner and to recipients of software distributed by the Project Owner a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer Your Contributions, where such license applies only to those patent claims licensable by You that are necessarily infringed by Your Contribution(s) alone or by combination of Your Contribution(s) with the Project to which such Contribution(s) was submitted.
|
||||
|
||||
## 4. Future Licensing Flexibility
|
||||
|
||||
You understand and agree that the Project Owner may, in the future, license the Project, including Your Contributions, under additional licenses beyond the current GNU Affero General Public License version 3.0 (AGPL-3.0). Such additional licenses may include commercial or enterprise licenses.
|
||||
|
||||
This provision ensures the Project has proper licensing flexibility should such licensing options be introduced in the future. The open source version of the Project will continue to be available under AGPL-3.0.
|
||||
|
||||
## 5. Representations
|
||||
|
||||
You represent that:
|
||||
|
||||
(a) You are legally entitled to grant the above licenses. If your employer(s) has rights to intellectual property that you create that includes your Contributions, you represent that you have received permission to make Contributions on behalf of that employer, or that your employer has waived such rights for your Contributions to the Project.
|
||||
|
||||
(b) Each of Your Contributions is Your original creation. You represent that Your Contribution submissions include complete details of any third-party license or other restriction (including, but not limited to, related patents and trademarks) of which you are personally aware and which are associated with any part of Your Contributions.
|
||||
|
||||
(c) Your Contribution does not violate any third-party rights, including but not limited to intellectual property rights, privacy rights, or contractual obligations.
|
||||
|
||||
## 6. Support and Warranty Disclaimer
|
||||
|
||||
You are not expected to provide support for Your Contributions, except to the extent You desire to provide support. You may provide support for free, for a fee, or not at all.
|
||||
|
||||
UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING, YOU PROVIDE YOUR CONTRIBUTIONS ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
|
||||
|
||||
## 7. No Obligation to Use
|
||||
|
||||
You understand that the decision to include Your Contribution in any project or source repository is entirely at the discretion of the Project Owner, and this Agreement does not guarantee that Your Contributions will be included in any product.
|
||||
|
||||
## 8. Contributor Rights
|
||||
|
||||
You retain full copyright ownership of Your Contributions. Nothing in this Agreement shall be interpreted to prohibit you from licensing Your Contributions under different terms to third parties or from using Your Contributions for any other purpose.
|
||||
|
||||
## 9. Notification
|
||||
|
||||
You agree to notify the Project Owner of any facts or circumstances of which you become aware that would make these representations inaccurate in any respect.
|
||||
|
||||
---
|
||||
|
||||
## How to Sign
|
||||
|
||||
To sign this CLA, comment on your Pull Request with:
|
||||
|
||||
```
|
||||
I have read the CLA Document and I hereby sign the CLA
|
||||
```
|
||||
|
||||
Your signature will be recorded automatically.
|
||||
|
||||
---
|
||||
|
||||
*This CLA is based on the Apache Software Foundation Individual Contributor License Agreement v2.0.*
|
||||
@@ -4,38 +4,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
|
||||
|
||||
## Project Overview
|
||||
|
||||
Auto Claude is a multi-agent autonomous coding framework that builds software through coordinated AI agent sessions. It uses the Claude Agent SDK to run agents in isolated workspaces with security controls.
|
||||
|
||||
**CRITICAL: All AI interactions use the Claude Agent SDK (`claude-agent-sdk` package), NOT the Anthropic API directly.**
|
||||
|
||||
## Project Structure
|
||||
|
||||
```
|
||||
autonomous-coding/
|
||||
├── apps/
|
||||
│ ├── backend/ # Python backend/CLI - ALL agent logic lives here
|
||||
│ │ ├── core/ # Client, auth, security
|
||||
│ │ ├── agents/ # Agent implementations
|
||||
│ │ ├── spec_agents/ # Spec creation agents
|
||||
│ │ ├── integrations/ # Graphiti, Linear, GitHub
|
||||
│ │ └── prompts/ # Agent system prompts
|
||||
│ └── frontend/ # Electron desktop UI
|
||||
├── guides/ # Documentation
|
||||
├── tests/ # Test suite
|
||||
└── scripts/ # Build and utility scripts
|
||||
```
|
||||
|
||||
**When working with AI/LLM code:**
|
||||
- Look in `apps/backend/core/client.py` for the Claude SDK client setup
|
||||
- Reference `apps/backend/agents/` for working agent implementations
|
||||
- Check `apps/backend/spec_agents/` for spec creation agent examples
|
||||
- NEVER use `anthropic.Anthropic()` directly - always use `create_client()` from `core.client`
|
||||
|
||||
**Frontend (Electron Desktop App):**
|
||||
- Built with Electron, React, TypeScript
|
||||
- AI agents can perform E2E testing using the Electron MCP server
|
||||
- When bug fixing or implementing features, use the Electron MCP server for automated testing
|
||||
- See "End-to-End Testing" section below for details
|
||||
Auto Claude is a multi-agent autonomous coding framework that builds software through coordinated AI agent sessions. It uses the Claude Code SDK to run agents in isolated workspaces with security controls.
|
||||
|
||||
## Commands
|
||||
|
||||
@@ -164,41 +133,19 @@ See [RELEASE.md](RELEASE.md) for detailed release process documentation.
|
||||
**Implementation (run.py → agent.py)** - Multi-session build:
|
||||
1. Planner Agent creates subtask-based implementation plan
|
||||
2. Coder Agent implements subtasks (can spawn subagents for parallel work)
|
||||
3. QA Reviewer validates acceptance criteria (can perform E2E testing via Electron MCP for frontend changes)
|
||||
4. QA Fixer resolves issues in a loop (with E2E testing to verify fixes)
|
||||
3. QA Reviewer validates acceptance criteria
|
||||
4. QA Fixer resolves issues in a loop
|
||||
|
||||
### Key Components (apps/backend/)
|
||||
|
||||
**Core Infrastructure:**
|
||||
- **core/client.py** - Claude Agent SDK client factory with security hooks and tool permissions
|
||||
- **core/security.py** - Dynamic command allowlisting based on detected project stack
|
||||
- **core/auth.py** - OAuth token management for Claude SDK authentication
|
||||
- **agents/** - Agent implementations (planner, coder, qa_reviewer, qa_fixer)
|
||||
- **spec_agents/** - Spec creation agents (gatherer, researcher, writer, critic)
|
||||
|
||||
**Memory & Context:**
|
||||
- **integrations/graphiti/** - Graphiti memory system (mandatory)
|
||||
- `queries_pkg/graphiti.py` - Main GraphitiMemory class
|
||||
- `queries_pkg/client.py` - LadybugDB client wrapper
|
||||
- `queries_pkg/queries.py` - Graph query operations
|
||||
- `queries_pkg/search.py` - Semantic search logic
|
||||
- `queries_pkg/schema.py` - Graph schema definitions
|
||||
- **client.py** - Claude SDK client with security hooks and tool permissions
|
||||
- **security.py** + **project_analyzer.py** - Dynamic command allowlisting based on detected project stack
|
||||
- **worktree.py** - Git worktree isolation for safe feature development
|
||||
- **memory.py** - File-based session memory (primary, always-available storage)
|
||||
- **graphiti_memory.py** - Graph-based cross-session memory with semantic search
|
||||
- **graphiti_providers.py** - Multi-provider factory for Graphiti (OpenAI, Anthropic, Azure, Ollama, Google AI)
|
||||
- **graphiti_config.py** - Configuration and validation for Graphiti integration
|
||||
- **graphiti_providers.py** - Multi-provider factory (OpenAI, Anthropic, Azure, Ollama, Google AI)
|
||||
- **agents/memory_manager.py** - Session memory orchestration
|
||||
|
||||
**Workspace & Security:**
|
||||
- **cli/worktree.py** - Git worktree isolation for safe feature development
|
||||
- **context/project_analyzer.py** - Project stack detection for dynamic tooling
|
||||
- **auto_claude_tools.py** - Custom MCP tools integration
|
||||
|
||||
**Integrations:**
|
||||
- **linear_updater.py** - Optional Linear integration for progress tracking
|
||||
- **runners/github/** - GitHub Issues & PRs automation
|
||||
- **Electron MCP** - E2E testing integration for QA agents (Chrome DevTools Protocol)
|
||||
- Enabled with `ELECTRON_MCP_ENABLED=true` in `.env`
|
||||
- Allows QA agents to interact with running Electron app
|
||||
- See "End-to-End Testing" section for details
|
||||
|
||||
### Agent Prompts (apps/backend/prompts/)
|
||||
|
||||
@@ -257,208 +204,35 @@ Three-layer defense:
|
||||
|
||||
Security profile cached in `.auto-claude-security.json`.
|
||||
|
||||
### Claude Agent SDK Integration
|
||||
|
||||
**CRITICAL: Auto Claude uses the Claude Agent SDK for ALL AI interactions. Never use the Anthropic API directly.**
|
||||
|
||||
**Client Location:** `apps/backend/core/client.py`
|
||||
|
||||
The `create_client()` function creates a configured `ClaudeSDKClient` instance with:
|
||||
- Multi-layered security (sandbox, permissions, security hooks)
|
||||
- Agent-specific tool permissions (planner, coder, qa_reviewer, qa_fixer)
|
||||
- Dynamic MCP server integration based on project capabilities
|
||||
- Extended thinking token budget control
|
||||
|
||||
**Example usage in agents:**
|
||||
```python
|
||||
from core.client import create_client
|
||||
|
||||
# Create SDK client (NOT raw Anthropic API client)
|
||||
client = create_client(
|
||||
project_dir=project_dir,
|
||||
spec_dir=spec_dir,
|
||||
model="claude-sonnet-4-5-20250929",
|
||||
agent_type="coder",
|
||||
max_thinking_tokens=None # or 5000/10000/16000
|
||||
)
|
||||
|
||||
# Run agent session
|
||||
response = client.create_agent_session(
|
||||
name="coder-agent-session",
|
||||
starting_message="Implement the authentication feature"
|
||||
)
|
||||
```
|
||||
|
||||
**Why use the SDK:**
|
||||
- Pre-configured security (sandbox, allowlists, hooks)
|
||||
- Automatic MCP server integration (Context7, Linear, Graphiti, Electron, Puppeteer)
|
||||
- Tool permissions based on agent role
|
||||
- Session management and recovery
|
||||
- Unified API across all agent types
|
||||
|
||||
**Where to find working examples:**
|
||||
- `apps/backend/agents/planner.py` - Planner agent
|
||||
- `apps/backend/agents/coder.py` - Coder agent
|
||||
- `apps/backend/agents/qa_reviewer.py` - QA reviewer
|
||||
- `apps/backend/agents/qa_fixer.py` - QA fixer
|
||||
- `apps/backend/spec_agents/` - Spec creation agents
|
||||
|
||||
### Memory System
|
||||
|
||||
**Graphiti Memory (Mandatory)** - `integrations/graphiti/`
|
||||
Dual-layer memory architecture:
|
||||
|
||||
Auto Claude uses Graphiti as its primary memory system with embedded LadybugDB (no Docker required):
|
||||
**File-Based Memory (Primary)** - `memory.py`
|
||||
- Zero dependencies, always available
|
||||
- Human-readable files in `specs/XXX/memory/`
|
||||
- Session insights, patterns, gotchas, codebase map
|
||||
|
||||
- **Graph database with semantic search** - Knowledge graph for cross-session context
|
||||
- **Session insights** - Patterns, gotchas, discoveries automatically extracted
|
||||
- **Multi-provider support:**
|
||||
**Graphiti Memory** - `graphiti_memory.py`
|
||||
- Graph database with semantic search (LadybugDB - embedded, no Docker)
|
||||
- Cross-session context retrieval
|
||||
- Multi-provider support:
|
||||
- LLM: OpenAI, Anthropic, Azure OpenAI, Ollama, Google AI (Gemini)
|
||||
- Embedders: OpenAI, Voyage AI, Azure OpenAI, Ollama, Google AI
|
||||
- **Modular architecture:** (`integrations/graphiti/queries_pkg/`)
|
||||
- `graphiti.py` - Main GraphitiMemory class
|
||||
- `client.py` - LadybugDB client wrapper
|
||||
- `queries.py` - Graph query operations
|
||||
- `search.py` - Semantic search logic
|
||||
- `schema.py` - Graph schema definitions
|
||||
- Configure with provider credentials in `.env.example`
|
||||
|
||||
**Configuration:**
|
||||
- Set provider credentials in `apps/backend/.env` (see `.env.example`)
|
||||
- Required env vars: `GRAPHITI_ENABLED=true`, `ANTHROPIC_API_KEY` or other provider keys
|
||||
- Memory data stored in `.auto-claude/specs/XXX/graphiti/`
|
||||
## Project Structure
|
||||
|
||||
**Usage in agents:**
|
||||
```python
|
||||
from integrations.graphiti.memory import get_graphiti_memory
|
||||
|
||||
memory = get_graphiti_memory(spec_dir, project_dir)
|
||||
context = memory.get_context_for_session("Implementing feature X")
|
||||
memory.add_session_insight("Pattern: use React hooks for state")
|
||||
```
|
||||
|
||||
## Development Guidelines
|
||||
|
||||
### Frontend Internationalization (i18n)
|
||||
|
||||
**CRITICAL: Always use i18n translation keys for all user-facing text in the frontend.**
|
||||
|
||||
The frontend uses `react-i18next` for internationalization. All labels, buttons, messages, and user-facing text MUST use translation keys.
|
||||
|
||||
**Translation file locations:**
|
||||
- `apps/frontend/src/shared/i18n/locales/en/*.json` - English translations
|
||||
- `apps/frontend/src/shared/i18n/locales/fr/*.json` - French translations
|
||||
|
||||
**Translation namespaces:**
|
||||
- `common.json` - Shared labels, buttons, common terms
|
||||
- `navigation.json` - Sidebar navigation items, sections
|
||||
- `settings.json` - Settings page content
|
||||
- `dialogs.json` - Dialog boxes and modals
|
||||
- `tasks.json` - Task/spec related content
|
||||
- `onboarding.json` - Onboarding wizard content
|
||||
- `welcome.json` - Welcome screen content
|
||||
|
||||
**Usage pattern:**
|
||||
```tsx
|
||||
import { useTranslation } from 'react-i18next';
|
||||
|
||||
// In component
|
||||
const { t } = useTranslation(['navigation', 'common']);
|
||||
|
||||
// Use translation keys, NOT hardcoded strings
|
||||
<span>{t('navigation:items.githubPRs')}</span> // ✅ CORRECT
|
||||
<span>GitHub PRs</span> // ❌ WRONG
|
||||
auto-claude/
|
||||
├── apps/
|
||||
│ ├── backend/ # Python backend/CLI (the framework code)
|
||||
│ └── frontend/ # Electron desktop UI
|
||||
├── guides/ # Documentation
|
||||
├── tests/ # Test suite
|
||||
└── scripts/ # Build and utility scripts
|
||||
```
|
||||
|
||||
**When adding new UI text:**
|
||||
1. Add the translation key to ALL language files (at minimum: `en/*.json` and `fr/*.json`)
|
||||
2. Use `namespace:section.key` format (e.g., `navigation:items.githubPRs`)
|
||||
3. Never use hardcoded strings in JSX/TSX files
|
||||
|
||||
### End-to-End Testing (Electron App)
|
||||
|
||||
**IMPORTANT: When bug fixing or implementing new features in the frontend, AI agents can perform automated E2E testing using the Electron MCP server.**
|
||||
|
||||
The Electron MCP server allows QA agents to interact with the running Electron app via Chrome DevTools Protocol:
|
||||
|
||||
**Setup:**
|
||||
1. Start the Electron app with remote debugging enabled:
|
||||
```bash
|
||||
npm run dev # Already configured with --remote-debugging-port=9222
|
||||
```
|
||||
|
||||
2. Enable Electron MCP in `apps/backend/.env`:
|
||||
```bash
|
||||
ELECTRON_MCP_ENABLED=true
|
||||
ELECTRON_DEBUG_PORT=9222 # Default port
|
||||
```
|
||||
|
||||
**Available Testing Capabilities:**
|
||||
|
||||
QA agents (`qa_reviewer` and `qa_fixer`) automatically get access to Electron MCP tools:
|
||||
|
||||
1. **Window Management**
|
||||
- `mcp__electron__get_electron_window_info` - Get info about running windows
|
||||
- `mcp__electron__take_screenshot` - Capture screenshots for visual verification
|
||||
|
||||
2. **UI Interaction**
|
||||
- `mcp__electron__send_command_to_electron` with commands:
|
||||
- `click_by_text` - Click buttons/links by visible text
|
||||
- `click_by_selector` - Click elements by CSS selector
|
||||
- `fill_input` - Fill form fields by placeholder or selector
|
||||
- `select_option` - Select dropdown options
|
||||
- `send_keyboard_shortcut` - Send keyboard shortcuts (Enter, Ctrl+N, etc.)
|
||||
- `navigate_to_hash` - Navigate to hash routes (#settings, #create, etc.)
|
||||
|
||||
3. **Page Inspection**
|
||||
- `get_page_structure` - Get organized overview of page elements
|
||||
- `debug_elements` - Get debugging info about buttons and forms
|
||||
- `verify_form_state` - Check form state and validation
|
||||
- `eval` - Execute custom JavaScript code
|
||||
|
||||
4. **Logging**
|
||||
- `mcp__electron__read_electron_logs` - Read console logs for debugging
|
||||
|
||||
**Example E2E Test Flow:**
|
||||
|
||||
```python
|
||||
# 1. Agent takes screenshot to see current state
|
||||
agent: "Take a screenshot to see the current UI"
|
||||
# Uses: mcp__electron__take_screenshot
|
||||
|
||||
# 2. Agent inspects page structure
|
||||
agent: "Get page structure to find available buttons"
|
||||
# Uses: mcp__electron__send_command_to_electron (command: "get_page_structure")
|
||||
|
||||
# 3. Agent clicks a button to navigate
|
||||
agent: "Click the 'Create New Spec' button"
|
||||
# Uses: mcp__electron__send_command_to_electron (command: "click_by_text", args: {text: "Create New Spec"})
|
||||
|
||||
# 4. Agent fills out a form
|
||||
agent: "Fill the task description field"
|
||||
# Uses: mcp__electron__send_command_to_electron (command: "fill_input", args: {placeholder: "Describe your task", value: "Add login feature"})
|
||||
|
||||
# 5. Agent submits and verifies
|
||||
agent: "Click Submit and verify success"
|
||||
# Uses: click_by_text → take_screenshot → verify result
|
||||
```
|
||||
|
||||
**When to Use E2E Testing:**
|
||||
|
||||
- **Bug Fixes**: Reproduce the bug, apply fix, verify it's resolved
|
||||
- **New Features**: Implement feature, test the UI flow end-to-end
|
||||
- **UI Changes**: Verify visual changes and interactions work correctly
|
||||
- **Form Validation**: Test form submission, validation, error handling
|
||||
|
||||
**Configuration in `core/client.py`:**
|
||||
|
||||
The client automatically enables Electron MCP tools for QA agents when:
|
||||
- Project is detected as Electron (`is_electron` capability)
|
||||
- `ELECTRON_MCP_ENABLED=true` is set
|
||||
- Agent type is `qa_reviewer` or `qa_fixer`
|
||||
|
||||
**Note:** Screenshots are automatically compressed (1280x720, quality 60, JPEG) to stay under Claude SDK's 1MB JSON message buffer limit.
|
||||
|
||||
## Running the Application
|
||||
|
||||
**As a standalone CLI tool**:
|
||||
```bash
|
||||
cd apps/backend
|
||||
@@ -468,14 +242,7 @@ python run.py --spec 001
|
||||
**With the Electron frontend**:
|
||||
```bash
|
||||
npm start # Build and run desktop app
|
||||
npm run dev # Run in development mode (includes --remote-debugging-port=9222 for E2E testing)
|
||||
npm run dev # Run in development mode
|
||||
```
|
||||
|
||||
**For E2E Testing with QA Agents:**
|
||||
1. Start the Electron app: `npm run dev`
|
||||
2. Enable Electron MCP in `apps/backend/.env`: `ELECTRON_MCP_ENABLED=true`
|
||||
3. Run QA: `python run.py --spec 001 --qa`
|
||||
4. QA agents will automatically interact with the running app for testing
|
||||
|
||||
**Project data storage:**
|
||||
- `.auto-claude/specs/` - Per-project data (specs, plans, QA reports, memory) - gitignored
|
||||
- `.auto-claude/specs/` - Per-project data (specs, plans, QA reports) - gitignored
|
||||
|
||||
@@ -4,7 +4,6 @@ Thank you for your interest in contributing to Auto Claude! This document provid
|
||||
|
||||
## Table of Contents
|
||||
|
||||
- [Contributor License Agreement (CLA)](#contributor-license-agreement-cla)
|
||||
- [Prerequisites](#prerequisites)
|
||||
- [Quick Start](#quick-start)
|
||||
- [Development Setup](#development-setup)
|
||||
@@ -24,30 +23,10 @@ Thank you for your interest in contributing to Auto Claude! This document provid
|
||||
- [Pull Request Targets](#pull-request-targets)
|
||||
- [Release Process](#release-process-maintainers)
|
||||
- [Commit Messages](#commit-messages)
|
||||
- [PR Hygiene](#pr-hygiene)
|
||||
- [Pull Request Process](#pull-request-process)
|
||||
- [Issue Reporting](#issue-reporting)
|
||||
- [Architecture Overview](#architecture-overview)
|
||||
|
||||
## Contributor License Agreement (CLA)
|
||||
|
||||
All contributors must sign our Contributor License Agreement (CLA) before contributions can be accepted.
|
||||
|
||||
### Why We Require a CLA
|
||||
|
||||
Auto Claude is currently licensed under AGPL-3.0. The CLA ensures the project has proper licensing flexibility should we introduce additional licensing options (such as commercial/enterprise licenses) in the future.
|
||||
|
||||
You retain full copyright ownership of your contributions.
|
||||
|
||||
### How to Sign
|
||||
|
||||
1. Open a Pull Request
|
||||
2. The CLA bot will automatically comment with instructions
|
||||
3. Comment on the PR with: `I have read the CLA Document and I hereby sign the CLA`
|
||||
4. Done - you only need to sign once, and it applies to all future contributions
|
||||
|
||||
Read the full CLA here: [CLA.md](CLA.md)
|
||||
|
||||
## Prerequisites
|
||||
|
||||
Before contributing, ensure you have the following installed:
|
||||
@@ -56,7 +35,6 @@ Before contributing, ensure you have the following installed:
|
||||
- **Node.js 24+** - For the Electron frontend
|
||||
- **npm 10+** - Package manager for the frontend (comes with Node.js)
|
||||
- **uv** (recommended) or **pip** - Python package manager
|
||||
- **CMake** - Required for building native dependencies (e.g., LadybugDB)
|
||||
- **Git** - Version control
|
||||
|
||||
### Installing Python 3.12
|
||||
@@ -76,26 +54,6 @@ brew install python@3.12
|
||||
sudo apt install python3.12 python3.12-venv
|
||||
```
|
||||
|
||||
### Installing CMake
|
||||
|
||||
**Windows:**
|
||||
|
||||
```bash
|
||||
winget install Kitware.CMake
|
||||
```
|
||||
|
||||
**macOS:**
|
||||
|
||||
```bash
|
||||
brew install cmake
|
||||
```
|
||||
|
||||
**Linux (Ubuntu/Debian):**
|
||||
|
||||
```bash
|
||||
sudo apt install cmake
|
||||
```
|
||||
|
||||
## Quick Start
|
||||
|
||||
The fastest way to get started:
|
||||
@@ -638,41 +596,6 @@ git commit -m "WIP"
|
||||
- **body**: Detailed explanation if needed (wrap at 72 chars)
|
||||
- **footer**: Reference issues, breaking changes
|
||||
|
||||
### PR Hygiene
|
||||
|
||||
**Rebasing:**
|
||||
- **Rebase onto develop** before opening a PR and before merge to maintain linear history
|
||||
- Use `git fetch origin && git rebase origin/develop` to sync your branch
|
||||
- Use `--force-with-lease` when force-pushing rebased branches (safer than `--force`)
|
||||
- Notify reviewers after force-pushing during active review
|
||||
- **Exception:** Never rebase after PR is approved and others have reviewed specific commits
|
||||
|
||||
**Commit organization:**
|
||||
- **Squash fixup commits** (typos, "oops", review feedback) into their parent commits
|
||||
- **Keep logically distinct changes** as separate commits that could be reverted independently
|
||||
- Each commit should compile and pass tests independently
|
||||
- No "WIP", "fix tests", or "lint" commits in final PR - squash these
|
||||
|
||||
**Before requesting review:**
|
||||
```bash
|
||||
# Ensure up-to-date with develop
|
||||
git fetch origin && git rebase origin/develop
|
||||
|
||||
# Clean up commit history (squash fixups, reword messages)
|
||||
git rebase -i origin/develop
|
||||
|
||||
# Force push with safety check
|
||||
git push --force-with-lease
|
||||
|
||||
# Verify everything works
|
||||
npm run test:backend
|
||||
cd apps/frontend && npm test && npm run lint && npm run typecheck
|
||||
```
|
||||
|
||||
**PR size:**
|
||||
- Keep PRs small (<400 lines changed ideally)
|
||||
- Split large features into stacked PRs if possible
|
||||
|
||||
## Pull Request Process
|
||||
|
||||
1. **Fork the repository** and create your branch from `develop` (not main!)
|
||||
|
||||
@@ -4,9 +4,7 @@
|
||||
|
||||
|
||||
|
||||
<!-- TOP_VERSION_BADGE -->
|
||||
[](https://github.com/AndyMik90/Auto-Claude/releases/tag/v2.7.1)
|
||||
<!-- TOP_VERSION_BADGE_END -->
|
||||
[](https://github.com/AndyMik90/Auto-Claude/releases/latest)
|
||||
[](./agpl-3.0.txt)
|
||||
[](https://discord.gg/KCXaPBr4Dj)
|
||||
[](https://github.com/AndyMik90/Auto-Claude/actions)
|
||||
@@ -15,40 +13,15 @@
|
||||
|
||||
## Download
|
||||
|
||||
### Stable Release
|
||||
Get the latest pre-built release for your platform:
|
||||
|
||||
<!-- STABLE_VERSION_BADGE -->
|
||||
[](https://github.com/AndyMik90/Auto-Claude/releases/tag/v2.7.1)
|
||||
<!-- STABLE_VERSION_BADGE_END -->
|
||||
|
||||
<!-- STABLE_DOWNLOADS -->
|
||||
| Platform | Download |
|
||||
|----------|----------|
|
||||
| **Windows** | [Auto-Claude-2.7.1-win32-x64.exe](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.1/Auto-Claude-2.7.1-win32-x64.exe) |
|
||||
| **macOS (Apple Silicon)** | [Auto-Claude-2.7.1-darwin-arm64.dmg](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.1/Auto-Claude-2.7.1-darwin-arm64.dmg) |
|
||||
| **macOS (Intel)** | [Auto-Claude-2.7.1-darwin-x64.dmg](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.1/Auto-Claude-2.7.1-darwin-x64.dmg) |
|
||||
| **Linux** | [Auto-Claude-2.7.1-linux-x86_64.AppImage](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.1/Auto-Claude-2.7.1-linux-x86_64.AppImage) |
|
||||
| **Linux (Debian)** | [Auto-Claude-2.7.1-linux-amd64.deb](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.1/Auto-Claude-2.7.1-linux-amd64.deb) |
|
||||
<!-- STABLE_DOWNLOADS_END -->
|
||||
|
||||
### Beta Release
|
||||
|
||||
> ⚠️ Beta releases may contain bugs and breaking changes. [View all releases](https://github.com/AndyMik90/Auto-Claude/releases)
|
||||
|
||||
<!-- BETA_VERSION_BADGE -->
|
||||
[](https://github.com/AndyMik90/Auto-Claude/releases/tag/v2.7.2-beta.10)
|
||||
<!-- BETA_VERSION_BADGE_END -->
|
||||
|
||||
<!-- BETA_DOWNLOADS -->
|
||||
| Platform | Download |
|
||||
|----------|----------|
|
||||
| **Windows** | [Auto-Claude-2.7.2-beta.10-win32-x64.exe](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.2-beta.10/Auto-Claude-2.7.2-beta.10-win32-x64.exe) |
|
||||
| **macOS (Apple Silicon)** | [Auto-Claude-2.7.2-beta.10-darwin-arm64.dmg](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.2-beta.10/Auto-Claude-2.7.2-beta.10-darwin-arm64.dmg) |
|
||||
| **macOS (Intel)** | [Auto-Claude-2.7.2-beta.10-darwin-x64.dmg](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.2-beta.10/Auto-Claude-2.7.2-beta.10-darwin-x64.dmg) |
|
||||
| **Linux** | [Auto-Claude-2.7.2-beta.10-linux-x86_64.AppImage](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.2-beta.10/Auto-Claude-2.7.2-beta.10-linux-x86_64.AppImage) |
|
||||
| **Linux (Debian)** | [Auto-Claude-2.7.2-beta.10-linux-amd64.deb](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.2-beta.10/Auto-Claude-2.7.2-beta.10-linux-amd64.deb) |
|
||||
| **Linux (Flatpak)** | [Auto-Claude-2.7.2-beta.10-linux-x86_64.flatpak](https://github.com/AndyMik90/Auto-Claude/releases/download/v2.7.2-beta.10/Auto-Claude-2.7.2-beta.10-linux-x86_64.flatpak) |
|
||||
<!-- BETA_DOWNLOADS_END -->
|
||||
| Platform | Download | Notes |
|
||||
|----------|----------|-------|
|
||||
| **Windows** | [Auto-Claude-2.7.1.exe](https://github.com/AndyMik90/Auto-Claude/releases/latest) | Installer (NSIS) |
|
||||
| **macOS (Apple Silicon)** | [Auto-Claude-2.7.1-arm64.dmg](https://github.com/AndyMik90/Auto-Claude/releases/latest) | M1/M2/M3 Macs |
|
||||
| **macOS (Intel)** | [Auto-Claude-2.7.1-x64.dmg](https://github.com/AndyMik90/Auto-Claude/releases/latest) | Intel Macs |
|
||||
| **Linux** | [Auto-Claude-2.7.1.AppImage](https://github.com/AndyMik90/Auto-Claude/releases/latest) | Universal |
|
||||
| **Linux (Debian)** | [Auto-Claude-2.7.1.deb](https://github.com/AndyMik90/Auto-Claude/releases/latest) | Ubuntu/Debian |
|
||||
|
||||
> All releases include SHA256 checksums and VirusTotal scan results for security verification.
|
||||
|
||||
@@ -188,28 +161,6 @@ npm start
|
||||
|
||||
See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed development setup.
|
||||
|
||||
### Building Flatpak
|
||||
|
||||
To build the Flatpak package, you need additional dependencies:
|
||||
|
||||
```bash
|
||||
# Fedora/RHEL
|
||||
sudo dnf install flatpak-builder
|
||||
|
||||
# Ubuntu/Debian
|
||||
sudo apt install flatpak-builder
|
||||
|
||||
# Install required Flatpak runtimes
|
||||
flatpak install flathub org.freedesktop.Platform//25.08 org.freedesktop.Sdk//25.08
|
||||
flatpak install flathub org.electronjs.Electron2.BaseApp//25.08
|
||||
|
||||
# Build the Flatpak
|
||||
cd apps/frontend
|
||||
npm run package:flatpak
|
||||
```
|
||||
|
||||
The Flatpak will be created in `apps/frontend/dist/`.
|
||||
|
||||
---
|
||||
|
||||
## Security
|
||||
@@ -238,7 +189,6 @@ All releases are:
|
||||
| `npm run package:mac` | Package for macOS |
|
||||
| `npm run package:win` | Package for Windows |
|
||||
| `npm run package:linux` | Package for Linux |
|
||||
| `npm run package:flatpak` | Package as Flatpak |
|
||||
| `npm run lint` | Run linter |
|
||||
| `npm test` | Run frontend tests |
|
||||
| `npm run test:backend` | Run backend tests |
|
||||
|
||||
@@ -153,10 +153,10 @@ GRAPHITI_ENABLED=true
|
||||
# Choose which providers to use for LLM and embeddings.
|
||||
# Default is "openai" for both.
|
||||
|
||||
# LLM provider: openai | anthropic | azure_openai | ollama | google | openrouter
|
||||
# LLM provider: openai | anthropic | azure_openai | ollama | google
|
||||
# GRAPHITI_LLM_PROVIDER=openai
|
||||
|
||||
# Embedder provider: openai | voyage | azure_openai | ollama | google | openrouter
|
||||
# Embedder provider: openai | voyage | azure_openai | ollama | google
|
||||
# GRAPHITI_EMBEDDER_PROVIDER=openai
|
||||
|
||||
# =============================================================================
|
||||
@@ -221,28 +221,6 @@ GRAPHITI_ENABLED=true
|
||||
# Google Embedding Model (default: text-embedding-004)
|
||||
# GOOGLE_EMBEDDING_MODEL=text-embedding-004
|
||||
|
||||
# =============================================================================
|
||||
# GRAPHITI: OpenRouter Provider (Multi-provider aggregator)
|
||||
# =============================================================================
|
||||
# Use OpenRouter to access multiple LLM providers through a single API.
|
||||
# OpenRouter provides access to Anthropic, OpenAI, Google, and many other models.
|
||||
# Get API key from: https://openrouter.ai/keys
|
||||
#
|
||||
# Required: OPENROUTER_API_KEY
|
||||
|
||||
# OpenRouter API Key
|
||||
# OPENROUTER_API_KEY=sk-or-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
|
||||
|
||||
# OpenRouter Base URL (default: https://openrouter.ai/api/v1)
|
||||
# OPENROUTER_BASE_URL=https://openrouter.ai/api/v1
|
||||
|
||||
# OpenRouter LLM Model (default: anthropic/claude-3.5-sonnet)
|
||||
# Popular choices: anthropic/claude-3.5-sonnet, openai/gpt-4o, google/gemini-2.0-flash
|
||||
# OPENROUTER_LLM_MODEL=anthropic/claude-3.5-sonnet
|
||||
|
||||
# OpenRouter Embedding Model (default: openai/text-embedding-3-small)
|
||||
# OPENROUTER_EMBEDDING_MODEL=openai/text-embedding-3-small
|
||||
|
||||
# =============================================================================
|
||||
# GRAPHITI: Azure OpenAI Provider
|
||||
# =============================================================================
|
||||
@@ -329,11 +307,3 @@ GRAPHITI_ENABLED=true
|
||||
# GRAPHITI_LLM_PROVIDER=google
|
||||
# GRAPHITI_EMBEDDER_PROVIDER=google
|
||||
# GOOGLE_API_KEY=AIzaSyxxxxxxxx
|
||||
#
|
||||
# --- Example 6: OpenRouter (multi-provider aggregator) ---
|
||||
# GRAPHITI_ENABLED=true
|
||||
# GRAPHITI_LLM_PROVIDER=openrouter
|
||||
# GRAPHITI_EMBEDDER_PROVIDER=openrouter
|
||||
# OPENROUTER_API_KEY=sk-or-xxxxxxxx
|
||||
# OPENROUTER_LLM_MODEL=anthropic/claude-3.5-sonnet
|
||||
# OPENROUTER_EMBEDDING_MODEL=openai/text-embedding-3-small
|
||||
|
||||
@@ -19,5 +19,5 @@ Quick Start:
|
||||
See README.md for full documentation.
|
||||
"""
|
||||
|
||||
__version__ = "2.7.2-beta.10"
|
||||
__version__ = "2.7.2"
|
||||
__author__ = "Auto Claude Team"
|
||||
|
||||
@@ -0,0 +1,62 @@
|
||||
"""
|
||||
Custom MCP Tools for Auto-Claude Agents
|
||||
========================================
|
||||
|
||||
DEPRECATED: This module is now a compatibility shim.
|
||||
Please import from the tools_pkg package instead:
|
||||
|
||||
from agents.tools_pkg import create_auto_claude_mcp_server, get_allowed_tools
|
||||
|
||||
This file remains for backward compatibility with existing imports.
|
||||
All functionality has been moved to the tools_pkg package for better
|
||||
organization and maintainability.
|
||||
"""
|
||||
|
||||
# Import everything from the package to maintain backward compatibility
|
||||
# Use try/except to handle both relative and absolute imports
|
||||
try:
|
||||
from .tools_pkg import (
|
||||
ELECTRON_TOOLS,
|
||||
TOOL_GET_BUILD_PROGRESS,
|
||||
TOOL_GET_SESSION_CONTEXT,
|
||||
TOOL_RECORD_DISCOVERY,
|
||||
TOOL_RECORD_GOTCHA,
|
||||
TOOL_UPDATE_QA_STATUS,
|
||||
TOOL_UPDATE_SUBTASK_STATUS,
|
||||
create_auto_claude_mcp_server,
|
||||
get_allowed_tools,
|
||||
is_electron_mcp_enabled,
|
||||
is_tools_available,
|
||||
)
|
||||
except ImportError:
|
||||
# Fallback for direct execution - import from tools_pkg directly
|
||||
from tools_pkg import (
|
||||
ELECTRON_TOOLS,
|
||||
TOOL_GET_BUILD_PROGRESS,
|
||||
TOOL_GET_SESSION_CONTEXT,
|
||||
TOOL_RECORD_DISCOVERY,
|
||||
TOOL_RECORD_GOTCHA,
|
||||
TOOL_UPDATE_QA_STATUS,
|
||||
TOOL_UPDATE_SUBTASK_STATUS,
|
||||
create_auto_claude_mcp_server,
|
||||
get_allowed_tools,
|
||||
is_electron_mcp_enabled,
|
||||
is_tools_available,
|
||||
)
|
||||
|
||||
__all__ = [
|
||||
# Main API
|
||||
"create_auto_claude_mcp_server",
|
||||
"get_allowed_tools",
|
||||
"is_tools_available",
|
||||
# Tool name constants
|
||||
"TOOL_UPDATE_SUBTASK_STATUS",
|
||||
"TOOL_GET_BUILD_PROGRESS",
|
||||
"TOOL_RECORD_DISCOVERY",
|
||||
"TOOL_RECORD_GOTCHA",
|
||||
"TOOL_GET_SESSION_CONTEXT",
|
||||
"TOOL_UPDATE_QA_STATUS",
|
||||
# Electron MCP
|
||||
"ELECTRON_TOOLS",
|
||||
"is_electron_mcp_enabled",
|
||||
]
|
||||
@@ -18,7 +18,6 @@ from linear_updater import (
|
||||
linear_task_stuck,
|
||||
)
|
||||
from phase_config import get_phase_model, get_phase_thinking_budget
|
||||
from phase_event import ExecutionPhase, emit_phase
|
||||
from progress import (
|
||||
count_subtasks,
|
||||
count_subtasks_detailed,
|
||||
@@ -147,7 +146,6 @@ async def run_autonomous_agent(
|
||||
|
||||
# Update status for planning phase
|
||||
status_manager.update(state=BuildState.PLANNING)
|
||||
emit_phase(ExecutionPhase.PLANNING, "Creating implementation plan")
|
||||
is_planning_phase = True
|
||||
current_log_phase = LogPhase.PLANNING
|
||||
|
||||
@@ -175,9 +173,6 @@ async def run_autonomous_agent(
|
||||
if task_logger:
|
||||
task_logger.start_phase(LogPhase.CODING, "Continuing implementation...")
|
||||
|
||||
# Emit phase event when continuing build
|
||||
emit_phase(ExecutionPhase.CODING, "Continuing implementation")
|
||||
|
||||
# Show human intervention hint
|
||||
content = [
|
||||
bold("INTERACTIVE CONTROLS"),
|
||||
@@ -278,7 +273,6 @@ async def run_autonomous_agent(
|
||||
if is_planning_phase:
|
||||
is_planning_phase = False
|
||||
current_log_phase = LogPhase.CODING
|
||||
emit_phase(ExecutionPhase.CODING, "Starting implementation")
|
||||
if task_logger:
|
||||
task_logger.end_phase(
|
||||
LogPhase.PLANNING,
|
||||
@@ -392,11 +386,10 @@ async def run_autonomous_agent(
|
||||
|
||||
# Handle session status
|
||||
if status == "complete":
|
||||
# Don't emit COMPLETE here - subtasks are done but QA hasn't run yet
|
||||
# QA loop will emit COMPLETE after actual approval
|
||||
print_build_complete_banner(spec_dir)
|
||||
status_manager.update(state=BuildState.COMPLETE)
|
||||
|
||||
# End coding phase in task logger
|
||||
if task_logger:
|
||||
task_logger.end_phase(
|
||||
LogPhase.CODING,
|
||||
@@ -404,6 +397,7 @@ async def run_autonomous_agent(
|
||||
message="All subtasks completed successfully",
|
||||
)
|
||||
|
||||
# Notify Linear that build is complete (moving to QA)
|
||||
if linear_task and linear_task.task_id:
|
||||
await linear_build_complete(spec_dir)
|
||||
print_status("Linear notified: build complete, ready for QA", "success")
|
||||
@@ -438,7 +432,6 @@ async def run_autonomous_agent(
|
||||
await asyncio.sleep(AUTO_CONTINUE_DELAY_SECONDS)
|
||||
|
||||
elif status == "error":
|
||||
emit_phase(ExecutionPhase.FAILED, "Session encountered an error")
|
||||
print_status("Session encountered an error", "error")
|
||||
print(muted("Will retry with a fresh session..."))
|
||||
status_manager.update(state=BuildState.ERROR)
|
||||
|
||||
@@ -10,7 +10,6 @@ from pathlib import Path
|
||||
|
||||
from core.client import create_client
|
||||
from phase_config import get_phase_thinking_budget
|
||||
from phase_event import ExecutionPhase, emit_phase
|
||||
from task_logger import (
|
||||
LogPhase,
|
||||
get_task_logger,
|
||||
@@ -68,7 +67,6 @@ async def run_followup_planner(
|
||||
# Initialize status manager for ccstatusline
|
||||
status_manager = StatusManager(project_dir)
|
||||
status_manager.set_active(spec_dir.name, BuildState.PLANNING)
|
||||
emit_phase(ExecutionPhase.PLANNING, "Follow-up planning")
|
||||
|
||||
# Initialize task logger for persistent logging
|
||||
task_logger = get_task_logger(spec_dir)
|
||||
|
||||
@@ -30,32 +30,16 @@ Usage:
|
||||
"""
|
||||
|
||||
from .models import (
|
||||
# Agent configuration registry
|
||||
AGENT_CONFIGS,
|
||||
# Base tools
|
||||
BASE_READ_TOOLS,
|
||||
BASE_WRITE_TOOLS,
|
||||
# MCP tool lists
|
||||
CONTEXT7_TOOLS,
|
||||
ELECTRON_TOOLS,
|
||||
GRAPHITI_MCP_TOOLS,
|
||||
LINEAR_TOOLS,
|
||||
PUPPETEER_TOOLS,
|
||||
# Auto-Claude tool names
|
||||
TOOL_GET_BUILD_PROGRESS,
|
||||
TOOL_GET_SESSION_CONTEXT,
|
||||
TOOL_RECORD_DISCOVERY,
|
||||
TOOL_RECORD_GOTCHA,
|
||||
TOOL_UPDATE_QA_STATUS,
|
||||
TOOL_UPDATE_SUBTASK_STATUS,
|
||||
WEB_TOOLS,
|
||||
# Config functions
|
||||
get_agent_config,
|
||||
get_default_thinking_level,
|
||||
get_required_mcp_servers,
|
||||
is_electron_mcp_enabled,
|
||||
)
|
||||
from .permissions import get_all_agent_types, get_allowed_tools
|
||||
from .permissions import get_allowed_tools
|
||||
from .registry import create_auto_claude_mcp_server, is_tools_available
|
||||
|
||||
__all__ = [
|
||||
@@ -63,29 +47,14 @@ __all__ = [
|
||||
"create_auto_claude_mcp_server",
|
||||
"get_allowed_tools",
|
||||
"is_tools_available",
|
||||
# Agent configuration registry
|
||||
"AGENT_CONFIGS",
|
||||
"get_agent_config",
|
||||
"get_required_mcp_servers",
|
||||
"get_default_thinking_level",
|
||||
"get_all_agent_types",
|
||||
# Base tool lists
|
||||
"BASE_READ_TOOLS",
|
||||
"BASE_WRITE_TOOLS",
|
||||
"WEB_TOOLS",
|
||||
# MCP tool lists
|
||||
"CONTEXT7_TOOLS",
|
||||
"LINEAR_TOOLS",
|
||||
"GRAPHITI_MCP_TOOLS",
|
||||
"ELECTRON_TOOLS",
|
||||
"PUPPETEER_TOOLS",
|
||||
# Auto-Claude tool name constants
|
||||
# Tool name constants
|
||||
"TOOL_UPDATE_SUBTASK_STATUS",
|
||||
"TOOL_GET_BUILD_PROGRESS",
|
||||
"TOOL_RECORD_DISCOVERY",
|
||||
"TOOL_RECORD_GOTCHA",
|
||||
"TOOL_GET_SESSION_CONTEXT",
|
||||
"TOOL_UPDATE_QA_STATUS",
|
||||
# Config
|
||||
# Electron MCP
|
||||
"ELECTRON_TOOLS",
|
||||
"is_electron_mcp_enabled",
|
||||
]
|
||||
|
||||
@@ -3,32 +3,12 @@ Tool Models and Constants
|
||||
==========================
|
||||
|
||||
Defines tool name constants and configuration for auto-claude MCP tools.
|
||||
|
||||
This module is the single source of truth for all tool definitions used by
|
||||
the Claude Agent SDK client. Tool lists are organized by category:
|
||||
|
||||
- Base tools: Core file operations (Read, Write, Edit, etc.)
|
||||
- Web tools: Documentation and research (WebFetch, WebSearch)
|
||||
- MCP tools: External integrations (Context7, Linear, Graphiti, etc.)
|
||||
- Auto-Claude tools: Custom build management tools
|
||||
"""
|
||||
|
||||
import os
|
||||
|
||||
# =============================================================================
|
||||
# Base Tools (Built-in Claude Code tools)
|
||||
# =============================================================================
|
||||
|
||||
# Core file operation tools
|
||||
BASE_READ_TOOLS = ["Read", "Glob", "Grep"]
|
||||
BASE_WRITE_TOOLS = ["Write", "Edit", "Bash"]
|
||||
|
||||
# Web tools for documentation lookup and research
|
||||
# Always available to all agents for accessing external information
|
||||
WEB_TOOLS = ["WebFetch", "WebSearch"]
|
||||
|
||||
# =============================================================================
|
||||
# Auto-Claude MCP Tools (Custom build management)
|
||||
# Tool Name Constants
|
||||
# =============================================================================
|
||||
|
||||
# Auto-Claude MCP tool names (prefixed with mcp__auto-claude__)
|
||||
@@ -39,54 +19,8 @@ TOOL_RECORD_GOTCHA = "mcp__auto-claude__record_gotcha"
|
||||
TOOL_GET_SESSION_CONTEXT = "mcp__auto-claude__get_session_context"
|
||||
TOOL_UPDATE_QA_STATUS = "mcp__auto-claude__update_qa_status"
|
||||
|
||||
# =============================================================================
|
||||
# External MCP Tools
|
||||
# =============================================================================
|
||||
|
||||
# Context7 MCP tools for documentation lookup (always enabled)
|
||||
CONTEXT7_TOOLS = [
|
||||
"mcp__context7__resolve-library-id",
|
||||
"mcp__context7__get-library-docs",
|
||||
]
|
||||
|
||||
# Linear MCP tools for project management (when LINEAR_API_KEY is set)
|
||||
LINEAR_TOOLS = [
|
||||
"mcp__linear-server__list_teams",
|
||||
"mcp__linear-server__get_team",
|
||||
"mcp__linear-server__list_projects",
|
||||
"mcp__linear-server__get_project",
|
||||
"mcp__linear-server__create_project",
|
||||
"mcp__linear-server__update_project",
|
||||
"mcp__linear-server__list_issues",
|
||||
"mcp__linear-server__get_issue",
|
||||
"mcp__linear-server__create_issue",
|
||||
"mcp__linear-server__update_issue",
|
||||
"mcp__linear-server__list_comments",
|
||||
"mcp__linear-server__create_comment",
|
||||
"mcp__linear-server__list_issue_statuses",
|
||||
"mcp__linear-server__list_issue_labels",
|
||||
"mcp__linear-server__list_users",
|
||||
"mcp__linear-server__get_user",
|
||||
]
|
||||
|
||||
# Graphiti MCP tools for knowledge graph memory (when GRAPHITI_MCP_URL is set)
|
||||
# See: https://github.com/getzep/graphiti
|
||||
GRAPHITI_MCP_TOOLS = [
|
||||
"mcp__graphiti-memory__search_nodes", # Search entity summaries
|
||||
"mcp__graphiti-memory__search_facts", # Search relationships between entities
|
||||
"mcp__graphiti-memory__add_episode", # Add data to knowledge graph
|
||||
"mcp__graphiti-memory__get_episodes", # Retrieve recent episodes
|
||||
"mcp__graphiti-memory__get_entity_edge", # Get specific entity/relationship
|
||||
]
|
||||
|
||||
# =============================================================================
|
||||
# Browser Automation MCP Tools (QA agents only)
|
||||
# =============================================================================
|
||||
|
||||
# Puppeteer MCP tools for web browser automation
|
||||
# Used for web frontend validation (non-Electron web apps)
|
||||
# NOTE: Screenshots must be compressed (1280x720, quality 60, JPEG) to stay under
|
||||
# Claude SDK's 1MB JSON message buffer limit. See GitHub issue #74.
|
||||
PUPPETEER_TOOLS = [
|
||||
"mcp__puppeteer__puppeteer_connect_active_tab",
|
||||
"mcp__puppeteer__puppeteer_navigate",
|
||||
@@ -102,7 +36,6 @@ PUPPETEER_TOOLS = [
|
||||
# Uses electron-mcp-server to connect to Electron apps via Chrome DevTools Protocol.
|
||||
# Electron app must be started with --remote-debugging-port=9222 (or ELECTRON_DEBUG_PORT).
|
||||
# These tools are only available to QA agents (qa_reviewer, qa_fixer), not Coder/Planner.
|
||||
# NOTE: Screenshots must be compressed to stay under Claude SDK's 1MB JSON message buffer limit.
|
||||
ELECTRON_TOOLS = [
|
||||
"mcp__electron__get_electron_window_info", # Get info about running Electron windows
|
||||
"mcp__electron__take_screenshot", # Capture screenshot of Electron window
|
||||
@@ -110,6 +43,10 @@ ELECTRON_TOOLS = [
|
||||
"mcp__electron__read_electron_logs", # Read console logs from Electron app
|
||||
]
|
||||
|
||||
# Base tools available to all agents
|
||||
BASE_READ_TOOLS = ["Read", "Glob", "Grep"]
|
||||
BASE_WRITE_TOOLS = ["Write", "Edit", "Bash"]
|
||||
|
||||
# =============================================================================
|
||||
# Configuration
|
||||
# =============================================================================
|
||||
@@ -124,280 +61,3 @@ def is_electron_mcp_enabled() -> bool:
|
||||
via Chrome DevTools Protocol on the configured debug port.
|
||||
"""
|
||||
return os.environ.get("ELECTRON_MCP_ENABLED", "").lower() == "true"
|
||||
|
||||
|
||||
# =============================================================================
|
||||
# Agent Configuration Registry
|
||||
# =============================================================================
|
||||
# Single source of truth for phase → tools → MCP servers mapping.
|
||||
# This enables phase-aware tool control and context window optimization.
|
||||
|
||||
AGENT_CONFIGS = {
|
||||
# ═══════════════════════════════════════════════════════════════════════
|
||||
# SPEC CREATION PHASES (Minimal tools, fast startup)
|
||||
# ═══════════════════════════════════════════════════════════════════════
|
||||
"spec_gatherer": {
|
||||
"tools": BASE_READ_TOOLS + WEB_TOOLS,
|
||||
"mcp_servers": [], # No MCP needed - just reads project
|
||||
"auto_claude_tools": [],
|
||||
"thinking_default": "medium",
|
||||
},
|
||||
"spec_researcher": {
|
||||
"tools": BASE_READ_TOOLS + WEB_TOOLS,
|
||||
"mcp_servers": ["context7"], # Needs docs lookup
|
||||
"auto_claude_tools": [],
|
||||
"thinking_default": "medium",
|
||||
},
|
||||
"spec_writer": {
|
||||
"tools": BASE_READ_TOOLS + BASE_WRITE_TOOLS,
|
||||
"mcp_servers": [], # Just writes spec.md
|
||||
"auto_claude_tools": [],
|
||||
"thinking_default": "high",
|
||||
},
|
||||
"spec_critic": {
|
||||
"tools": BASE_READ_TOOLS,
|
||||
"mcp_servers": [], # Self-critique, no external tools
|
||||
"auto_claude_tools": [],
|
||||
"thinking_default": "ultrathink",
|
||||
},
|
||||
"spec_discovery": {
|
||||
"tools": BASE_READ_TOOLS + WEB_TOOLS,
|
||||
"mcp_servers": [],
|
||||
"auto_claude_tools": [],
|
||||
"thinking_default": "medium",
|
||||
},
|
||||
"spec_context": {
|
||||
"tools": BASE_READ_TOOLS,
|
||||
"mcp_servers": [],
|
||||
"auto_claude_tools": [],
|
||||
"thinking_default": "medium",
|
||||
},
|
||||
"spec_validation": {
|
||||
"tools": BASE_READ_TOOLS,
|
||||
"mcp_servers": [],
|
||||
"auto_claude_tools": [],
|
||||
"thinking_default": "high",
|
||||
},
|
||||
"spec_compaction": {
|
||||
"tools": BASE_READ_TOOLS + BASE_WRITE_TOOLS,
|
||||
"mcp_servers": [],
|
||||
"auto_claude_tools": [],
|
||||
"thinking_default": "medium",
|
||||
},
|
||||
# ═══════════════════════════════════════════════════════════════════════
|
||||
# BUILD PHASES (Full tools + Graphiti memory)
|
||||
# Note: "linear" is conditional on project setting "update_linear_with_tasks"
|
||||
# ═══════════════════════════════════════════════════════════════════════
|
||||
"planner": {
|
||||
"tools": BASE_READ_TOOLS + BASE_WRITE_TOOLS + WEB_TOOLS,
|
||||
"mcp_servers": ["context7", "graphiti", "auto-claude"],
|
||||
"mcp_servers_optional": ["linear"], # Only if project setting enabled
|
||||
"auto_claude_tools": [
|
||||
TOOL_GET_BUILD_PROGRESS,
|
||||
TOOL_GET_SESSION_CONTEXT,
|
||||
TOOL_RECORD_DISCOVERY,
|
||||
],
|
||||
"thinking_default": "high",
|
||||
},
|
||||
"coder": {
|
||||
"tools": BASE_READ_TOOLS + BASE_WRITE_TOOLS + WEB_TOOLS,
|
||||
"mcp_servers": ["context7", "graphiti", "auto-claude"],
|
||||
"mcp_servers_optional": ["linear"],
|
||||
"auto_claude_tools": [
|
||||
TOOL_UPDATE_SUBTASK_STATUS,
|
||||
TOOL_GET_BUILD_PROGRESS,
|
||||
TOOL_RECORD_DISCOVERY,
|
||||
TOOL_RECORD_GOTCHA,
|
||||
TOOL_GET_SESSION_CONTEXT,
|
||||
],
|
||||
"thinking_default": "none", # Coding doesn't use extended thinking
|
||||
},
|
||||
# ═══════════════════════════════════════════════════════════════════════
|
||||
# QA PHASES (Read + test + browser + Graphiti memory)
|
||||
# ═══════════════════════════════════════════════════════════════════════
|
||||
"qa_reviewer": {
|
||||
# Read-only + Bash (for running tests) - reviewer should NOT edit code
|
||||
"tools": BASE_READ_TOOLS + ["Bash"] + WEB_TOOLS,
|
||||
"mcp_servers": ["context7", "graphiti", "auto-claude", "browser"],
|
||||
"mcp_servers_optional": ["linear"], # For updating issue status
|
||||
"auto_claude_tools": [
|
||||
TOOL_GET_BUILD_PROGRESS,
|
||||
TOOL_UPDATE_QA_STATUS,
|
||||
TOOL_GET_SESSION_CONTEXT,
|
||||
],
|
||||
"thinking_default": "high",
|
||||
},
|
||||
"qa_fixer": {
|
||||
"tools": BASE_READ_TOOLS + BASE_WRITE_TOOLS + WEB_TOOLS,
|
||||
"mcp_servers": ["context7", "graphiti", "auto-claude", "browser"],
|
||||
"mcp_servers_optional": ["linear"],
|
||||
"auto_claude_tools": [
|
||||
TOOL_UPDATE_SUBTASK_STATUS,
|
||||
TOOL_GET_BUILD_PROGRESS,
|
||||
TOOL_UPDATE_QA_STATUS,
|
||||
TOOL_RECORD_GOTCHA,
|
||||
],
|
||||
"thinking_default": "medium",
|
||||
},
|
||||
# ═══════════════════════════════════════════════════════════════════════
|
||||
# UTILITY PHASES (Minimal, no MCP)
|
||||
# ═══════════════════════════════════════════════════════════════════════
|
||||
"insights": {
|
||||
"tools": BASE_READ_TOOLS + WEB_TOOLS,
|
||||
"mcp_servers": [],
|
||||
"auto_claude_tools": [],
|
||||
"thinking_default": "medium",
|
||||
},
|
||||
"merge_resolver": {
|
||||
"tools": [], # Text-only analysis
|
||||
"mcp_servers": [],
|
||||
"auto_claude_tools": [],
|
||||
"thinking_default": "low",
|
||||
},
|
||||
"commit_message": {
|
||||
"tools": [],
|
||||
"mcp_servers": [],
|
||||
"auto_claude_tools": [],
|
||||
"thinking_default": "low",
|
||||
},
|
||||
"pr_reviewer": {
|
||||
"tools": BASE_READ_TOOLS + WEB_TOOLS, # Read-only
|
||||
"mcp_servers": ["context7"],
|
||||
"auto_claude_tools": [],
|
||||
"thinking_default": "high",
|
||||
},
|
||||
# ═══════════════════════════════════════════════════════════════════════
|
||||
# ANALYSIS PHASES
|
||||
# ═══════════════════════════════════════════════════════════════════════
|
||||
"analysis": {
|
||||
"tools": BASE_READ_TOOLS + WEB_TOOLS,
|
||||
"mcp_servers": ["context7"],
|
||||
"auto_claude_tools": [],
|
||||
"thinking_default": "medium",
|
||||
},
|
||||
"batch_analysis": {
|
||||
"tools": BASE_READ_TOOLS + WEB_TOOLS,
|
||||
"mcp_servers": [],
|
||||
"auto_claude_tools": [],
|
||||
"thinking_default": "low",
|
||||
},
|
||||
"batch_validation": {
|
||||
"tools": BASE_READ_TOOLS,
|
||||
"mcp_servers": [],
|
||||
"auto_claude_tools": [],
|
||||
"thinking_default": "low",
|
||||
},
|
||||
# ═══════════════════════════════════════════════════════════════════════
|
||||
# ROADMAP & IDEATION
|
||||
# ═══════════════════════════════════════════════════════════════════════
|
||||
"roadmap_discovery": {
|
||||
"tools": BASE_READ_TOOLS + WEB_TOOLS,
|
||||
"mcp_servers": ["context7"],
|
||||
"auto_claude_tools": [],
|
||||
"thinking_default": "high",
|
||||
},
|
||||
"competitor_analysis": {
|
||||
"tools": BASE_READ_TOOLS + WEB_TOOLS,
|
||||
"mcp_servers": ["context7"], # WebSearch for competitor research
|
||||
"auto_claude_tools": [],
|
||||
"thinking_default": "high",
|
||||
},
|
||||
"ideation": {
|
||||
"tools": BASE_READ_TOOLS + WEB_TOOLS,
|
||||
"mcp_servers": [],
|
||||
"auto_claude_tools": [],
|
||||
"thinking_default": "high",
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
# =============================================================================
|
||||
# Agent Config Helper Functions
|
||||
# =============================================================================
|
||||
|
||||
|
||||
def get_agent_config(agent_type: str) -> dict:
|
||||
"""
|
||||
Get full configuration for an agent type.
|
||||
|
||||
Args:
|
||||
agent_type: The agent type identifier (e.g., 'coder', 'planner', 'qa_reviewer')
|
||||
|
||||
Returns:
|
||||
Configuration dict containing tools, mcp_servers, auto_claude_tools, thinking_default
|
||||
|
||||
Raises:
|
||||
ValueError: If agent_type is not found in AGENT_CONFIGS (strict mode)
|
||||
"""
|
||||
if agent_type not in AGENT_CONFIGS:
|
||||
raise ValueError(
|
||||
f"Unknown agent type: '{agent_type}'. "
|
||||
f"Valid types: {sorted(AGENT_CONFIGS.keys())}"
|
||||
)
|
||||
return AGENT_CONFIGS[agent_type]
|
||||
|
||||
|
||||
def get_required_mcp_servers(
|
||||
agent_type: str,
|
||||
project_capabilities: dict | None = None,
|
||||
linear_enabled: bool = False,
|
||||
) -> list[str]:
|
||||
"""
|
||||
Get MCP servers required for this agent type.
|
||||
|
||||
Handles dynamic server selection:
|
||||
- "browser" → electron (if is_electron) or puppeteer (if is_web_frontend)
|
||||
- "linear" → only if in mcp_servers_optional AND linear_enabled is True
|
||||
- "graphiti" → only if GRAPHITI_MCP_URL is set
|
||||
|
||||
Args:
|
||||
agent_type: The agent type identifier
|
||||
project_capabilities: Dict from detect_project_capabilities() or None
|
||||
linear_enabled: Whether Linear integration is enabled for this project
|
||||
|
||||
Returns:
|
||||
List of MCP server names to start
|
||||
"""
|
||||
config = get_agent_config(agent_type)
|
||||
servers = list(config.get("mcp_servers", []))
|
||||
|
||||
# Handle optional servers (e.g., Linear if project setting enabled)
|
||||
optional = config.get("mcp_servers_optional", [])
|
||||
if "linear" in optional and linear_enabled:
|
||||
servers.append("linear")
|
||||
|
||||
# Handle dynamic "browser" → electron/puppeteer based on project type
|
||||
if "browser" in servers:
|
||||
servers = [s for s in servers if s != "browser"]
|
||||
if project_capabilities:
|
||||
is_electron = project_capabilities.get("is_electron", False)
|
||||
is_web_frontend = project_capabilities.get("is_web_frontend", False)
|
||||
|
||||
if is_electron and is_electron_mcp_enabled():
|
||||
servers.append("electron")
|
||||
elif is_web_frontend and not is_electron:
|
||||
servers.append("puppeteer")
|
||||
|
||||
# Filter graphiti if not enabled
|
||||
if "graphiti" in servers:
|
||||
if not os.environ.get("GRAPHITI_MCP_URL"):
|
||||
servers = [s for s in servers if s != "graphiti"]
|
||||
|
||||
return servers
|
||||
|
||||
|
||||
def get_default_thinking_level(agent_type: str) -> str:
|
||||
"""
|
||||
Get default thinking level string for agent type.
|
||||
|
||||
This returns the thinking level name (e.g., 'medium', 'high'), not the token budget.
|
||||
To convert to tokens, use phase_config.get_thinking_budget(level).
|
||||
|
||||
Args:
|
||||
agent_type: The agent type identifier
|
||||
|
||||
Returns:
|
||||
Thinking level string (none, low, medium, high, ultrathink)
|
||||
"""
|
||||
config = get_agent_config(agent_type)
|
||||
return config.get("thinking_default", "medium")
|
||||
|
||||
@@ -8,29 +8,26 @@ pollution and accidental misuse.
|
||||
Supports dynamic tool filtering based on project capabilities to optimize
|
||||
context window usage. For example, Electron tools are only included for
|
||||
Electron projects, not for Next.js or CLI projects.
|
||||
|
||||
This module now uses AGENT_CONFIGS from models.py as the single source of truth
|
||||
for tool permissions. The get_allowed_tools() function remains the primary API
|
||||
for backwards compatibility.
|
||||
"""
|
||||
|
||||
from .models import (
|
||||
AGENT_CONFIGS,
|
||||
CONTEXT7_TOOLS,
|
||||
BASE_READ_TOOLS,
|
||||
BASE_WRITE_TOOLS,
|
||||
ELECTRON_TOOLS,
|
||||
GRAPHITI_MCP_TOOLS,
|
||||
LINEAR_TOOLS,
|
||||
PUPPETEER_TOOLS,
|
||||
get_agent_config,
|
||||
get_required_mcp_servers,
|
||||
TOOL_GET_BUILD_PROGRESS,
|
||||
TOOL_GET_SESSION_CONTEXT,
|
||||
TOOL_RECORD_DISCOVERY,
|
||||
TOOL_RECORD_GOTCHA,
|
||||
TOOL_UPDATE_QA_STATUS,
|
||||
TOOL_UPDATE_SUBTASK_STATUS,
|
||||
is_electron_mcp_enabled,
|
||||
)
|
||||
from .registry import is_tools_available
|
||||
|
||||
|
||||
def get_allowed_tools(
|
||||
agent_type: str,
|
||||
project_capabilities: dict | None = None,
|
||||
linear_enabled: bool = False,
|
||||
) -> list[str]:
|
||||
"""
|
||||
Get the list of allowed tools for a specific agent type.
|
||||
@@ -38,80 +35,107 @@ def get_allowed_tools(
|
||||
This ensures each agent only sees tools relevant to their role,
|
||||
preventing context pollution and accidental misuse.
|
||||
|
||||
Uses AGENT_CONFIGS as the single source of truth for tool permissions.
|
||||
Dynamic MCP tools are added based on project capabilities and required servers.
|
||||
When project_capabilities is provided, MCP tools are filtered based on
|
||||
the project type. For example:
|
||||
- Electron projects get Electron MCP tools
|
||||
- Web frontends (non-Electron) get Puppeteer MCP tools
|
||||
- CLI projects get neither
|
||||
|
||||
Args:
|
||||
agent_type: Agent type identifier (e.g., 'coder', 'planner', 'qa_reviewer')
|
||||
agent_type: One of 'planner', 'coder', 'qa_reviewer', 'qa_fixer'
|
||||
project_capabilities: Optional dict from detect_project_capabilities()
|
||||
containing flags like is_electron, is_web_frontend, etc.
|
||||
linear_enabled: Whether Linear integration is enabled for this project
|
||||
|
||||
Returns:
|
||||
List of allowed tool names
|
||||
|
||||
Raises:
|
||||
ValueError: If agent_type is not found in AGENT_CONFIGS
|
||||
"""
|
||||
# Get agent configuration (raises ValueError if unknown type)
|
||||
config = get_agent_config(agent_type)
|
||||
# Auto-claude tool mappings by agent type
|
||||
tool_mappings = {
|
||||
"planner": {
|
||||
"base": BASE_READ_TOOLS + BASE_WRITE_TOOLS,
|
||||
"auto_claude": [
|
||||
TOOL_GET_BUILD_PROGRESS,
|
||||
TOOL_GET_SESSION_CONTEXT,
|
||||
TOOL_RECORD_DISCOVERY,
|
||||
],
|
||||
},
|
||||
"coder": {
|
||||
"base": BASE_READ_TOOLS + BASE_WRITE_TOOLS,
|
||||
"auto_claude": [
|
||||
TOOL_UPDATE_SUBTASK_STATUS,
|
||||
TOOL_GET_BUILD_PROGRESS,
|
||||
TOOL_RECORD_DISCOVERY,
|
||||
TOOL_RECORD_GOTCHA,
|
||||
TOOL_GET_SESSION_CONTEXT,
|
||||
],
|
||||
},
|
||||
"qa_reviewer": {
|
||||
"base": BASE_READ_TOOLS + ["Bash"], # Can run tests but not edit
|
||||
"auto_claude": [
|
||||
TOOL_GET_BUILD_PROGRESS,
|
||||
TOOL_UPDATE_QA_STATUS,
|
||||
TOOL_GET_SESSION_CONTEXT,
|
||||
],
|
||||
},
|
||||
"qa_fixer": {
|
||||
"base": BASE_READ_TOOLS + BASE_WRITE_TOOLS,
|
||||
"auto_claude": [
|
||||
TOOL_UPDATE_SUBTASK_STATUS,
|
||||
TOOL_GET_BUILD_PROGRESS,
|
||||
TOOL_UPDATE_QA_STATUS,
|
||||
TOOL_RECORD_GOTCHA,
|
||||
],
|
||||
},
|
||||
}
|
||||
|
||||
# Start with base tools from config
|
||||
tools = list(config.get("tools", []))
|
||||
if agent_type not in tool_mappings:
|
||||
# Default to coder tools
|
||||
agent_type = "coder"
|
||||
|
||||
# Get required MCP servers for this agent
|
||||
required_servers = get_required_mcp_servers(
|
||||
agent_type,
|
||||
project_capabilities,
|
||||
linear_enabled,
|
||||
)
|
||||
mapping = tool_mappings[agent_type]
|
||||
tools = mapping["base"] + mapping["auto_claude"]
|
||||
|
||||
# Add auto-claude tools ONLY if the MCP server is available
|
||||
# This prevents allowing tools that won't work because the server isn't running
|
||||
if "auto-claude" in required_servers and is_tools_available():
|
||||
tools.extend(config.get("auto_claude_tools", []))
|
||||
|
||||
# Add MCP tool names based on required servers
|
||||
tools.extend(_get_mcp_tools_for_servers(required_servers))
|
||||
# Add MCP tools for QA agents only, based on project capabilities
|
||||
if agent_type in ("qa_reviewer", "qa_fixer"):
|
||||
tools.extend(_get_qa_mcp_tools(project_capabilities))
|
||||
|
||||
return tools
|
||||
|
||||
|
||||
def _get_mcp_tools_for_servers(servers: list[str]) -> list[str]:
|
||||
def _get_qa_mcp_tools(project_capabilities: dict | None) -> list[str]:
|
||||
"""
|
||||
Get the list of MCP tools for a list of required servers.
|
||||
Get the list of MCP tools for QA agents based on project capabilities.
|
||||
|
||||
Maps server names to their corresponding tool lists.
|
||||
This function determines which MCP tools to include based on:
|
||||
1. Project type detection (Electron, web frontend, etc.)
|
||||
2. Environment variables (ELECTRON_MCP_ENABLED)
|
||||
|
||||
Args:
|
||||
servers: List of MCP server names (e.g., ['context7', 'linear', 'electron'])
|
||||
project_capabilities: Dict from detect_project_capabilities() or None
|
||||
|
||||
Returns:
|
||||
List of MCP tool names for all specified servers
|
||||
List of MCP tool names to include
|
||||
"""
|
||||
tools = []
|
||||
|
||||
for server in servers:
|
||||
if server == "context7":
|
||||
tools.extend(CONTEXT7_TOOLS)
|
||||
elif server == "linear":
|
||||
tools.extend(LINEAR_TOOLS)
|
||||
elif server == "graphiti":
|
||||
tools.extend(GRAPHITI_MCP_TOOLS)
|
||||
elif server == "electron":
|
||||
# If no capabilities provided, fall back to legacy behavior
|
||||
# (check env var only)
|
||||
if project_capabilities is None:
|
||||
if is_electron_mcp_enabled():
|
||||
tools.extend(ELECTRON_TOOLS)
|
||||
elif server == "puppeteer":
|
||||
tools.extend(PUPPETEER_TOOLS)
|
||||
# auto-claude tools are already added via config["auto_claude_tools"]
|
||||
return tools
|
||||
|
||||
# Project-capability-based tool selection
|
||||
is_electron = project_capabilities.get("is_electron", False)
|
||||
is_web_frontend = project_capabilities.get("is_web_frontend", False)
|
||||
|
||||
# Electron projects get Electron MCP tools (if enabled)
|
||||
if is_electron and is_electron_mcp_enabled():
|
||||
tools.extend(ELECTRON_TOOLS)
|
||||
|
||||
# Web frontends (non-Electron) get Puppeteer tools
|
||||
# Puppeteer is always available, no env var check needed
|
||||
if is_web_frontend and not is_electron:
|
||||
tools.extend(PUPPETEER_TOOLS)
|
||||
|
||||
return tools
|
||||
|
||||
|
||||
def get_all_agent_types() -> list[str]:
|
||||
"""
|
||||
Get all registered agent types.
|
||||
|
||||
Returns:
|
||||
Sorted list of all agent type identifiers
|
||||
"""
|
||||
return sorted(AGENT_CONFIGS.keys())
|
||||
|
||||
@@ -75,15 +75,6 @@ class FrameworkAnalyzer(BaseAnalyzer):
|
||||
content = self._read_file("Cargo.toml")
|
||||
self._detect_rust_framework(content)
|
||||
|
||||
# Swift/iOS detection (check BEFORE Ruby - iOS projects often have Gemfile for CocoaPods/Fastlane)
|
||||
elif self._exists("Package.swift") or any(self.path.glob("*.xcodeproj")):
|
||||
self.analysis["language"] = "Swift"
|
||||
if self._exists("Package.swift"):
|
||||
self.analysis["package_manager"] = "Swift Package Manager"
|
||||
else:
|
||||
self.analysis["package_manager"] = "Xcode"
|
||||
self._detect_swift_framework()
|
||||
|
||||
# Ruby detection
|
||||
elif self._exists("Gemfile"):
|
||||
self.analysis["language"] = "Ruby"
|
||||
@@ -299,109 +290,6 @@ class FrameworkAnalyzer(BaseAnalyzer):
|
||||
if "sidekiq" in content.lower():
|
||||
self.analysis["task_queue"] = "Sidekiq"
|
||||
|
||||
def _detect_swift_framework(self) -> None:
|
||||
"""Detect Swift/iOS framework and dependencies."""
|
||||
try:
|
||||
# Scan Swift files for imports, excluding hidden/vendor dirs
|
||||
swift_files = []
|
||||
for swift_file in self.path.rglob("*.swift"):
|
||||
# Skip hidden directories, node_modules, .worktrees, etc.
|
||||
if any(
|
||||
part.startswith(".") or part in ("node_modules", "Pods", "Carthage")
|
||||
for part in swift_file.parts
|
||||
):
|
||||
continue
|
||||
swift_files.append(swift_file)
|
||||
if len(swift_files) >= 50: # Limit for performance
|
||||
break
|
||||
|
||||
imports = set()
|
||||
for swift_file in swift_files:
|
||||
try:
|
||||
content = swift_file.read_text(encoding="utf-8", errors="ignore")
|
||||
for line in content.split("\n"):
|
||||
line = line.strip()
|
||||
if line.startswith("import "):
|
||||
module = line.replace("import ", "").split()[0]
|
||||
imports.add(module)
|
||||
except Exception:
|
||||
continue
|
||||
|
||||
# Detect UI framework
|
||||
if "SwiftUI" in imports:
|
||||
self.analysis["framework"] = "SwiftUI"
|
||||
self.analysis["type"] = "mobile"
|
||||
elif "UIKit" in imports:
|
||||
self.analysis["framework"] = "UIKit"
|
||||
self.analysis["type"] = "mobile"
|
||||
elif "AppKit" in imports:
|
||||
self.analysis["framework"] = "AppKit"
|
||||
self.analysis["type"] = "desktop"
|
||||
|
||||
# Detect iOS/Apple frameworks
|
||||
apple_frameworks = []
|
||||
framework_map = {
|
||||
"Combine": "Combine",
|
||||
"CoreData": "CoreData",
|
||||
"MapKit": "MapKit",
|
||||
"WidgetKit": "WidgetKit",
|
||||
"CoreLocation": "CoreLocation",
|
||||
"StoreKit": "StoreKit",
|
||||
"CloudKit": "CloudKit",
|
||||
"ActivityKit": "ActivityKit",
|
||||
"UserNotifications": "UserNotifications",
|
||||
}
|
||||
for key, name in framework_map.items():
|
||||
if key in imports:
|
||||
apple_frameworks.append(name)
|
||||
|
||||
if apple_frameworks:
|
||||
self.analysis["apple_frameworks"] = apple_frameworks
|
||||
|
||||
# Detect SPM dependencies from Package.swift or xcodeproj
|
||||
dependencies = self._detect_spm_dependencies()
|
||||
if dependencies:
|
||||
self.analysis["spm_dependencies"] = dependencies
|
||||
except Exception:
|
||||
# Silently fail if Swift detection has issues
|
||||
pass
|
||||
|
||||
def _detect_spm_dependencies(self) -> list[str]:
|
||||
"""Detect Swift Package Manager dependencies."""
|
||||
dependencies = []
|
||||
|
||||
# Try Package.swift first
|
||||
if self._exists("Package.swift"):
|
||||
content = self._read_file("Package.swift")
|
||||
# Look for .package(url: "...", patterns
|
||||
import re
|
||||
|
||||
urls = re.findall(r'\.package\s*\([^)]*url:\s*"([^"]+)"', content)
|
||||
for url in urls:
|
||||
# Extract package name from URL
|
||||
name = url.rstrip("/").split("/")[-1].replace(".git", "")
|
||||
if name:
|
||||
dependencies.append(name)
|
||||
|
||||
# Also check xcodeproj for XCRemoteSwiftPackageReference
|
||||
for xcodeproj in self.path.glob("*.xcodeproj"):
|
||||
pbxproj = xcodeproj / "project.pbxproj"
|
||||
if pbxproj.exists():
|
||||
try:
|
||||
content = pbxproj.read_text(encoding="utf-8", errors="ignore")
|
||||
import re
|
||||
|
||||
# Match repositoryURL patterns
|
||||
urls = re.findall(r'repositoryURL\s*=\s*"([^"]+)"', content)
|
||||
for url in urls:
|
||||
name = url.rstrip("/").split("/")[-1].replace(".git", "")
|
||||
if name and name not in dependencies:
|
||||
dependencies.append(name)
|
||||
except Exception:
|
||||
continue
|
||||
|
||||
return dependencies
|
||||
|
||||
def _detect_node_package_manager(self) -> str:
|
||||
"""Detect Node.js package manager."""
|
||||
if self._exists("pnpm-lock.yaml"):
|
||||
|
||||
@@ -366,19 +366,19 @@ async def run_insight_extraction(
|
||||
cwd = str(project_dir.resolve()) if project_dir else os.getcwd()
|
||||
|
||||
try:
|
||||
# Use simple_client for insight extraction
|
||||
from pathlib import Path
|
||||
|
||||
from core.simple_client import create_simple_client
|
||||
|
||||
client = create_simple_client(
|
||||
agent_type="insights",
|
||||
model=model,
|
||||
system_prompt=(
|
||||
"You are an expert code analyst. You extract structured insights from coding sessions. "
|
||||
"Always respond with valid JSON only, no markdown formatting or explanations."
|
||||
),
|
||||
cwd=Path(cwd) if cwd else None,
|
||||
# Create a minimal SDK client for insight extraction
|
||||
# No tools needed - just text generation
|
||||
client = ClaudeSDKClient(
|
||||
options=ClaudeAgentOptions(
|
||||
model=model,
|
||||
system_prompt=(
|
||||
"You are an expert code analyst. You extract structured insights from coding sessions. "
|
||||
"Always respond with valid JSON only, no markdown formatting or explanations."
|
||||
),
|
||||
allowed_tools=[], # No tools needed for extraction
|
||||
max_turns=1, # Single turn extraction
|
||||
cwd=cwd,
|
||||
)
|
||||
)
|
||||
|
||||
# Use async context manager
|
||||
|
||||
@@ -15,6 +15,10 @@ _PARENT_DIR = Path(__file__).parent.parent
|
||||
if str(_PARENT_DIR) not in sys.path:
|
||||
sys.path.insert(0, str(_PARENT_DIR))
|
||||
|
||||
from ui import (
|
||||
Icons,
|
||||
icon,
|
||||
)
|
||||
|
||||
from .batch_commands import (
|
||||
handle_batch_cleanup_command,
|
||||
@@ -197,6 +201,13 @@ Environment Variables:
|
||||
help="Show human review/approval status for a spec",
|
||||
)
|
||||
|
||||
# Dev mode (deprecated)
|
||||
parser.add_argument(
|
||||
"--dev",
|
||||
action="store_true",
|
||||
help="[Deprecated] No longer has any effect - kept for compatibility",
|
||||
)
|
||||
|
||||
# Non-interactive mode (for UI/automation)
|
||||
parser.add_argument(
|
||||
"--auto-continue",
|
||||
@@ -279,10 +290,16 @@ def main() -> None:
|
||||
# Get model (with env var fallback)
|
||||
model = args.model or os.environ.get("AUTO_BUILD_MODEL", DEFAULT_MODEL)
|
||||
|
||||
# Note: --dev flag is deprecated but kept for API compatibility
|
||||
if args.dev:
|
||||
print(
|
||||
f"\n{icon(Icons.GEAR)} Note: --dev flag is deprecated. All specs now use .auto-claude/specs/\n"
|
||||
)
|
||||
|
||||
# Handle --list command
|
||||
if args.list:
|
||||
print_banner()
|
||||
print_specs_list(project_dir)
|
||||
print_specs_list(project_dir, args.dev)
|
||||
return
|
||||
|
||||
# Handle --list-worktrees command
|
||||
@@ -320,14 +337,14 @@ def main() -> None:
|
||||
sys.exit(1)
|
||||
|
||||
# Find the spec
|
||||
debug("run.py", "Finding spec", spec_identifier=args.spec)
|
||||
spec_dir = find_spec(project_dir, args.spec)
|
||||
debug("run.py", "Finding spec", spec_identifier=args.spec, dev_mode=args.dev)
|
||||
spec_dir = find_spec(project_dir, args.spec, args.dev)
|
||||
if not spec_dir:
|
||||
debug_error("run.py", "Spec not found", spec=args.spec)
|
||||
print_banner()
|
||||
print(f"\nError: Spec '{args.spec}' not found")
|
||||
print("\nAvailable specs:")
|
||||
print_specs_list(project_dir)
|
||||
print_specs_list(project_dir, args.dev)
|
||||
sys.exit(1)
|
||||
|
||||
debug_success("run.py", "Spec found", spec_dir=str(spec_dir))
|
||||
|
||||
@@ -19,17 +19,18 @@ from workspace import get_existing_build_worktree
|
||||
from .utils import get_specs_dir
|
||||
|
||||
|
||||
def list_specs(project_dir: Path) -> list[dict]:
|
||||
def list_specs(project_dir: Path, dev_mode: bool = False) -> list[dict]:
|
||||
"""
|
||||
List all specs in the project.
|
||||
|
||||
Args:
|
||||
project_dir: Project root directory
|
||||
dev_mode: If True, use dev/auto-claude/specs/
|
||||
|
||||
Returns:
|
||||
List of spec info dicts with keys: number, name, path, status, progress
|
||||
"""
|
||||
specs_dir = get_specs_dir(project_dir)
|
||||
specs_dir = get_specs_dir(project_dir, dev_mode)
|
||||
specs = []
|
||||
|
||||
if not specs_dir.exists():
|
||||
@@ -92,16 +93,19 @@ def list_specs(project_dir: Path) -> list[dict]:
|
||||
return specs
|
||||
|
||||
|
||||
def print_specs_list(project_dir: Path, auto_create: bool = True) -> None:
|
||||
def print_specs_list(
|
||||
project_dir: Path, dev_mode: bool = False, auto_create: bool = True
|
||||
) -> None:
|
||||
"""Print a formatted list of all specs.
|
||||
|
||||
Args:
|
||||
project_dir: Project root directory
|
||||
dev_mode: If True, use dev/auto-claude/specs/
|
||||
auto_create: If True and no specs exist, automatically launch spec creation
|
||||
"""
|
||||
import subprocess
|
||||
|
||||
specs = list_specs(project_dir)
|
||||
specs = list_specs(project_dir, dev_mode)
|
||||
|
||||
if not specs:
|
||||
print("\nNo specs found.")
|
||||
|
||||
+16
-37
@@ -54,56 +54,35 @@ def setup_environment() -> Path:
|
||||
return script_dir
|
||||
|
||||
|
||||
def find_spec(project_dir: Path, spec_identifier: str) -> Path | None:
|
||||
def find_spec(
|
||||
project_dir: Path, spec_identifier: str, dev_mode: bool = False
|
||||
) -> Path | None:
|
||||
"""
|
||||
Find a spec by number or full name.
|
||||
|
||||
Args:
|
||||
project_dir: Project root directory
|
||||
spec_identifier: Either "001" or "001-feature-name"
|
||||
dev_mode: If True, use dev/auto-claude/specs/
|
||||
|
||||
Returns:
|
||||
Path to spec folder, or None if not found
|
||||
"""
|
||||
specs_dir = get_specs_dir(project_dir)
|
||||
specs_dir = get_specs_dir(project_dir, dev_mode)
|
||||
|
||||
if specs_dir.exists():
|
||||
# Try exact match first
|
||||
exact_path = specs_dir / spec_identifier
|
||||
if exact_path.exists() and (exact_path / "spec.md").exists():
|
||||
return exact_path
|
||||
if not specs_dir.exists():
|
||||
return None
|
||||
|
||||
# Try matching by number prefix
|
||||
for spec_folder in specs_dir.iterdir():
|
||||
if spec_folder.is_dir() and spec_folder.name.startswith(
|
||||
spec_identifier + "-"
|
||||
):
|
||||
if (spec_folder / "spec.md").exists():
|
||||
return spec_folder
|
||||
# Try exact match first
|
||||
exact_path = specs_dir / spec_identifier
|
||||
if exact_path.exists() and (exact_path / "spec.md").exists():
|
||||
return exact_path
|
||||
|
||||
# Check worktree specs (for merge-preview, merge, review, discard operations)
|
||||
worktree_base = project_dir / ".worktrees"
|
||||
if worktree_base.exists():
|
||||
# Try exact match in worktree
|
||||
worktree_spec = (
|
||||
worktree_base / spec_identifier / ".auto-claude" / "specs" / spec_identifier
|
||||
)
|
||||
if worktree_spec.exists() and (worktree_spec / "spec.md").exists():
|
||||
return worktree_spec
|
||||
|
||||
# Try matching by prefix in worktrees
|
||||
for worktree_dir in worktree_base.iterdir():
|
||||
if worktree_dir.is_dir() and worktree_dir.name.startswith(
|
||||
spec_identifier + "-"
|
||||
):
|
||||
spec_in_worktree = (
|
||||
worktree_dir / ".auto-claude" / "specs" / worktree_dir.name
|
||||
)
|
||||
if (
|
||||
spec_in_worktree.exists()
|
||||
and (spec_in_worktree / "spec.md").exists()
|
||||
):
|
||||
return spec_in_worktree
|
||||
# Try matching by number prefix
|
||||
for spec_folder in specs_dir.iterdir():
|
||||
if spec_folder.is_dir() and spec_folder.name.startswith(spec_identifier + "-"):
|
||||
if (spec_folder / "spec.md").exists():
|
||||
return spec_folder
|
||||
|
||||
return None
|
||||
|
||||
|
||||
@@ -14,14 +14,7 @@ _PARENT_DIR = Path(__file__).parent.parent
|
||||
if str(_PARENT_DIR) not in sys.path:
|
||||
sys.path.insert(0, str(_PARENT_DIR))
|
||||
|
||||
from core.workspace.git_utils import (
|
||||
_is_auto_claude_file,
|
||||
apply_path_mapping,
|
||||
detect_file_renames,
|
||||
get_file_content_from_ref,
|
||||
get_merge_base,
|
||||
is_lock_file,
|
||||
)
|
||||
from core.workspace.git_utils import _is_auto_claude_file, is_lock_file
|
||||
from debug import debug_warning
|
||||
from ui import (
|
||||
Icons,
|
||||
@@ -687,58 +680,6 @@ def handle_merge_preview_command(
|
||||
# but we want to show the user all files that will be merged
|
||||
total_files_from_git = len(all_changed_files)
|
||||
|
||||
# Detect files that need AI merge due to path mappings (file renames)
|
||||
# This happens when the target branch has renamed/moved files that the
|
||||
# worktree modified at their old locations
|
||||
path_mapped_ai_merges: list[dict] = []
|
||||
path_mappings: dict[str, str] = {}
|
||||
|
||||
if git_conflicts["needs_rebase"] and git_conflicts["commits_behind"] > 0:
|
||||
# Get the merge-base between the branches
|
||||
spec_branch = git_conflicts["spec_branch"]
|
||||
base_branch = git_conflicts["base_branch"]
|
||||
merge_base = get_merge_base(project_dir, spec_branch, base_branch)
|
||||
|
||||
if merge_base:
|
||||
# Detect file renames between merge-base and current base branch
|
||||
path_mappings = detect_file_renames(
|
||||
project_dir, merge_base, base_branch
|
||||
)
|
||||
|
||||
if path_mappings:
|
||||
debug(
|
||||
MODULE,
|
||||
f"Detected {len(path_mappings)} file rename(s) between merge-base and target",
|
||||
sample_mappings={
|
||||
k: v for k, v in list(path_mappings.items())[:3]
|
||||
},
|
||||
)
|
||||
|
||||
# Check which changed files have path mappings and need AI merge
|
||||
for file_path in all_changed_files:
|
||||
mapped_path = apply_path_mapping(file_path, path_mappings)
|
||||
if mapped_path != file_path:
|
||||
# File was renamed - check if both versions exist
|
||||
worktree_content = get_file_content_from_ref(
|
||||
project_dir, spec_branch, file_path
|
||||
)
|
||||
target_content = get_file_content_from_ref(
|
||||
project_dir, base_branch, mapped_path
|
||||
)
|
||||
|
||||
if worktree_content and target_content:
|
||||
path_mapped_ai_merges.append(
|
||||
{
|
||||
"oldPath": file_path,
|
||||
"newPath": mapped_path,
|
||||
"reason": "File was renamed/moved and modified in both branches",
|
||||
}
|
||||
)
|
||||
debug(
|
||||
MODULE,
|
||||
f"Path-mapped file needs AI merge: {file_path} -> {mapped_path}",
|
||||
)
|
||||
|
||||
result = {
|
||||
"success": True,
|
||||
# Use git diff files as the authoritative list of files to merge
|
||||
@@ -752,9 +693,6 @@ def handle_merge_preview_command(
|
||||
"commitsBehind": git_conflicts["commits_behind"],
|
||||
"baseBranch": git_conflicts["base_branch"],
|
||||
"specBranch": git_conflicts["spec_branch"],
|
||||
# Path-mapped files that need AI merge due to renames
|
||||
"pathMappedAIMerges": path_mapped_ai_merges,
|
||||
"totalRenames": len(path_mappings),
|
||||
},
|
||||
"summary": {
|
||||
# Use git diff count, not semantic tracker count
|
||||
@@ -764,8 +702,6 @@ def handle_merge_preview_command(
|
||||
"autoMergeable": summary.get("auto_mergeable", 0),
|
||||
"hasGitConflicts": git_conflicts["has_conflicts"]
|
||||
and len(non_lock_conflicting_files) > 0,
|
||||
# Include path-mapped AI merge count for UI display
|
||||
"pathMappedAIMergeCount": len(path_mapped_ai_merges),
|
||||
},
|
||||
# Include lock files info so UI can optionally show them
|
||||
"lockFilesExcluded": lock_files_excluded,
|
||||
@@ -780,8 +716,6 @@ def handle_merge_preview_command(
|
||||
total_conflicts=result["summary"]["totalConflicts"],
|
||||
has_git_conflicts=git_conflicts["has_conflicts"],
|
||||
auto_mergeable=result["summary"]["autoMergeable"],
|
||||
path_mapped_ai_merges=len(path_mapped_ai_merges),
|
||||
total_renames=len(path_mappings),
|
||||
)
|
||||
|
||||
return result
|
||||
@@ -802,6 +736,5 @@ def handle_merge_preview_command(
|
||||
"conflictFiles": 0,
|
||||
"totalConflicts": 0,
|
||||
"autoMergeable": 0,
|
||||
"pathMappedAIMergeCount": 0,
|
||||
},
|
||||
}
|
||||
|
||||
@@ -197,16 +197,19 @@ async def _call_claude_haiku(prompt: str) -> str:
|
||||
ensure_claude_code_oauth_token()
|
||||
|
||||
try:
|
||||
from core.simple_client import create_simple_client
|
||||
from claude_agent_sdk import ClaudeAgentOptions, ClaudeSDKClient
|
||||
except ImportError:
|
||||
logger.warning("core.simple_client not available")
|
||||
logger.warning("claude_agent_sdk not installed")
|
||||
return ""
|
||||
|
||||
client = create_simple_client(
|
||||
agent_type="commit_message",
|
||||
model="claude-haiku-4-5-20251001",
|
||||
system_prompt=SYSTEM_PROMPT,
|
||||
max_thinking_tokens=1024, # Low thinking for speed
|
||||
client = ClaudeSDKClient(
|
||||
options=ClaudeAgentOptions(
|
||||
model="claude-haiku-4-5-20251001",
|
||||
system_prompt=SYSTEM_PROMPT,
|
||||
allowed_tools=[],
|
||||
max_turns=1,
|
||||
max_thinking_tokens=1024, # Low thinking for speed
|
||||
)
|
||||
)
|
||||
|
||||
try:
|
||||
|
||||
+184
-188
@@ -3,30 +3,19 @@ Claude SDK Client Configuration
|
||||
===============================
|
||||
|
||||
Functions for creating and configuring the Claude Agent SDK client.
|
||||
|
||||
All AI interactions should use `create_client()` to ensure consistent OAuth authentication
|
||||
and proper tool/MCP configuration. For simple message calls without full agent sessions,
|
||||
use `create_simple_client()` from `core.simple_client`.
|
||||
|
||||
The client factory now uses AGENT_CONFIGS from agents/tools_pkg/models.py as the
|
||||
single source of truth for phase-aware tool and MCP server configuration.
|
||||
"""
|
||||
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
from agents.tools_pkg import (
|
||||
CONTEXT7_TOOLS,
|
||||
ELECTRON_TOOLS,
|
||||
GRAPHITI_MCP_TOOLS,
|
||||
LINEAR_TOOLS,
|
||||
PUPPETEER_TOOLS,
|
||||
from auto_claude_tools import (
|
||||
create_auto_claude_mcp_server,
|
||||
get_allowed_tools,
|
||||
get_required_mcp_servers,
|
||||
is_tools_available,
|
||||
)
|
||||
from auto_claude_tools import (
|
||||
get_allowed_tools as get_agent_allowed_tools,
|
||||
)
|
||||
from claude_agent_sdk import ClaudeAgentOptions, ClaudeSDKClient
|
||||
from claude_agent_sdk.types import HookMatcher
|
||||
from core.auth import get_sdk_env_vars, require_auth_token
|
||||
@@ -66,28 +55,78 @@ def get_electron_debug_port() -> int:
|
||||
return int(os.environ.get("ELECTRON_DEBUG_PORT", "9222"))
|
||||
|
||||
|
||||
def should_use_claude_md() -> bool:
|
||||
"""Check if CLAUDE.md instructions should be included in system prompt."""
|
||||
return os.environ.get("USE_CLAUDE_MD", "").lower() == "true"
|
||||
# Puppeteer MCP tools for browser automation
|
||||
# NOTE: Screenshots must be compressed (1280x720, quality 60, JPEG) to stay under
|
||||
# Claude SDK's 1MB JSON message buffer limit. See GitHub issue #74.
|
||||
PUPPETEER_TOOLS = [
|
||||
"mcp__puppeteer__puppeteer_connect_active_tab",
|
||||
"mcp__puppeteer__puppeteer_navigate",
|
||||
"mcp__puppeteer__puppeteer_screenshot",
|
||||
"mcp__puppeteer__puppeteer_click",
|
||||
"mcp__puppeteer__puppeteer_fill",
|
||||
"mcp__puppeteer__puppeteer_select",
|
||||
"mcp__puppeteer__puppeteer_hover",
|
||||
"mcp__puppeteer__puppeteer_evaluate",
|
||||
]
|
||||
|
||||
# Linear MCP tools for project management (when LINEAR_API_KEY is set)
|
||||
LINEAR_TOOLS = [
|
||||
"mcp__linear-server__list_teams",
|
||||
"mcp__linear-server__get_team",
|
||||
"mcp__linear-server__list_projects",
|
||||
"mcp__linear-server__get_project",
|
||||
"mcp__linear-server__create_project",
|
||||
"mcp__linear-server__update_project",
|
||||
"mcp__linear-server__list_issues",
|
||||
"mcp__linear-server__get_issue",
|
||||
"mcp__linear-server__create_issue",
|
||||
"mcp__linear-server__update_issue",
|
||||
"mcp__linear-server__list_comments",
|
||||
"mcp__linear-server__create_comment",
|
||||
"mcp__linear-server__list_issue_statuses",
|
||||
"mcp__linear-server__list_issue_labels",
|
||||
"mcp__linear-server__list_users",
|
||||
"mcp__linear-server__get_user",
|
||||
]
|
||||
|
||||
def load_claude_md(project_dir: Path) -> str | None:
|
||||
"""
|
||||
Load CLAUDE.md content from project root if it exists.
|
||||
# Context7 MCP tools for documentation lookup (always enabled)
|
||||
CONTEXT7_TOOLS = [
|
||||
"mcp__context7__resolve-library-id",
|
||||
"mcp__context7__get-library-docs",
|
||||
]
|
||||
|
||||
Args:
|
||||
project_dir: Root directory of the project
|
||||
# Graphiti MCP tools for knowledge graph memory (when GRAPHITI_MCP_ENABLED is set)
|
||||
# See: https://github.com/getzep/graphiti
|
||||
GRAPHITI_MCP_TOOLS = [
|
||||
"mcp__graphiti-memory__search_nodes", # Search entity summaries
|
||||
"mcp__graphiti-memory__search_facts", # Search relationships between entities
|
||||
"mcp__graphiti-memory__add_episode", # Add data to knowledge graph
|
||||
"mcp__graphiti-memory__get_episodes", # Retrieve recent episodes
|
||||
"mcp__graphiti-memory__get_entity_edge", # Get specific entity/relationship
|
||||
]
|
||||
|
||||
Returns:
|
||||
Content of CLAUDE.md if found, None otherwise
|
||||
"""
|
||||
claude_md_path = project_dir / "CLAUDE.md"
|
||||
if claude_md_path.exists():
|
||||
try:
|
||||
return claude_md_path.read_text(encoding="utf-8")
|
||||
except Exception:
|
||||
return None
|
||||
return None
|
||||
# Electron MCP tools for desktop app automation (when ELECTRON_MCP_ENABLED is set)
|
||||
# Uses electron-mcp-server to connect to Electron apps via Chrome DevTools Protocol.
|
||||
# Electron app must be started with --remote-debugging-port=9222 (or ELECTRON_DEBUG_PORT).
|
||||
# These tools are only available to QA agents (qa_reviewer, qa_fixer), not Coder/Planner.
|
||||
# NOTE: Screenshots must be compressed to stay under Claude SDK's 1MB JSON message buffer limit.
|
||||
# See GitHub issue #74.
|
||||
ELECTRON_TOOLS = [
|
||||
"mcp__electron__get_electron_window_info", # Get info about running Electron windows
|
||||
"mcp__electron__take_screenshot", # Capture screenshot of Electron window
|
||||
"mcp__electron__send_command_to_electron", # Send commands (click, fill, evaluate JS)
|
||||
"mcp__electron__read_electron_logs", # Read console logs from Electron app
|
||||
]
|
||||
|
||||
# Built-in tools
|
||||
BUILTIN_TOOLS = [
|
||||
"Read",
|
||||
"Write",
|
||||
"Edit",
|
||||
"Glob",
|
||||
"Grep",
|
||||
"Bash",
|
||||
]
|
||||
|
||||
|
||||
def create_client(
|
||||
@@ -96,36 +135,25 @@ def create_client(
|
||||
model: str,
|
||||
agent_type: str = "coder",
|
||||
max_thinking_tokens: int | None = None,
|
||||
output_format: dict | None = None,
|
||||
) -> ClaudeSDKClient:
|
||||
"""
|
||||
Create a Claude Agent SDK client with multi-layered security.
|
||||
|
||||
Uses AGENT_CONFIGS for phase-aware tool and MCP server configuration.
|
||||
Only starts MCP servers that the agent actually needs, reducing context
|
||||
window bloat and startup latency.
|
||||
|
||||
Args:
|
||||
project_dir: Root directory for the project (working directory)
|
||||
spec_dir: Directory containing the spec (for settings file)
|
||||
model: Claude model to use
|
||||
agent_type: Agent type identifier from AGENT_CONFIGS
|
||||
(e.g., 'coder', 'planner', 'qa_reviewer', 'spec_gatherer')
|
||||
agent_type: Type of agent - 'planner', 'coder', 'qa_reviewer', or 'qa_fixer'
|
||||
This determines which custom auto-claude tools are available.
|
||||
max_thinking_tokens: Token budget for extended thinking (None = disabled)
|
||||
- ultrathink: 16000 (spec creation)
|
||||
- high: 10000 (QA review)
|
||||
- medium: 5000 (planning, validation)
|
||||
- None: disabled (coding)
|
||||
output_format: Optional structured output format for validated JSON responses.
|
||||
Use {"type": "json_schema", "schema": Model.model_json_schema()}
|
||||
See: https://platform.claude.com/docs/en/agent-sdk/structured-outputs
|
||||
|
||||
Returns:
|
||||
Configured ClaudeSDKClient
|
||||
|
||||
Raises:
|
||||
ValueError: If agent_type is not found in AGENT_CONFIGS
|
||||
|
||||
Security layers (defense in depth):
|
||||
1. Sandbox - OS-level bash command isolation prevents filesystem escape
|
||||
2. Permissions - File operations restricted to project_dir only
|
||||
@@ -152,78 +180,68 @@ def create_client(
|
||||
project_index = load_project_index(project_dir)
|
||||
project_capabilities = detect_project_capabilities(project_index)
|
||||
|
||||
# Get allowed tools using phase-aware configuration
|
||||
# This respects AGENT_CONFIGS and only includes tools the agent needs
|
||||
allowed_tools_list = get_allowed_tools(
|
||||
agent_type,
|
||||
project_capabilities,
|
||||
linear_enabled,
|
||||
)
|
||||
# Build the list of allowed tools
|
||||
# Start with agent-specific tools (includes base tools + auto-claude tools)
|
||||
# Pass project capabilities for dynamic MCP tool filtering
|
||||
if auto_claude_tools_enabled:
|
||||
allowed_tools_list = get_agent_allowed_tools(agent_type, project_capabilities)
|
||||
else:
|
||||
allowed_tools_list = [*BUILTIN_TOOLS]
|
||||
|
||||
# Get required MCP servers for this agent type
|
||||
# This is the key optimization - only start servers the agent needs
|
||||
required_servers = get_required_mcp_servers(
|
||||
agent_type,
|
||||
project_capabilities,
|
||||
linear_enabled,
|
||||
)
|
||||
# Check if Graphiti MCP is enabled
|
||||
graphiti_mcp_enabled = is_graphiti_mcp_enabled()
|
||||
|
||||
# Check if Graphiti MCP is enabled (already filtered by get_required_mcp_servers)
|
||||
graphiti_mcp_enabled = "graphiti" in required_servers
|
||||
# Check if Electron MCP is enabled (for QA agents testing Electron apps)
|
||||
electron_mcp_enabled = is_electron_mcp_enabled()
|
||||
|
||||
# Determine browser tools for permissions (already in allowed_tools_list)
|
||||
# Add external MCP tools based on project capabilities
|
||||
# This saves context window by only including relevant tools
|
||||
allowed_tools_list.extend(CONTEXT7_TOOLS) # Always available
|
||||
if linear_enabled:
|
||||
allowed_tools_list.extend(LINEAR_TOOLS)
|
||||
if graphiti_mcp_enabled:
|
||||
allowed_tools_list.extend(GRAPHITI_MCP_TOOLS)
|
||||
# Note: Browser automation tools (ELECTRON_TOOLS, PUPPETEER_TOOLS) are already
|
||||
# added by get_agent_allowed_tools() via _get_qa_mcp_tools() for QA agents
|
||||
|
||||
# Determine which browser automation tools to allow based on project type
|
||||
# Note: Must check "not is_electron" for Puppeteer to avoid tool mismatch
|
||||
# when Electron MCP is disabled for an Electron project
|
||||
browser_tools_permissions = []
|
||||
if "electron" in required_servers:
|
||||
browser_tools_permissions = ELECTRON_TOOLS
|
||||
elif "puppeteer" in required_servers:
|
||||
browser_tools_permissions = PUPPETEER_TOOLS
|
||||
if agent_type in ("qa_reviewer", "qa_fixer"):
|
||||
if project_capabilities.get("is_electron") and electron_mcp_enabled:
|
||||
browser_tools_permissions = ELECTRON_TOOLS
|
||||
elif project_capabilities.get(
|
||||
"is_web_frontend"
|
||||
) and not project_capabilities.get("is_electron"):
|
||||
# Only add Puppeteer for non-Electron web frontends
|
||||
browser_tools_permissions = PUPPETEER_TOOLS
|
||||
|
||||
# Create comprehensive security settings
|
||||
# Note: Using both relative paths ("./**") and absolute paths to handle
|
||||
# cases where Claude uses absolute paths for file operations
|
||||
project_path_str = str(project_dir.resolve())
|
||||
# Note: Using relative paths ("./**") restricts access to project directory
|
||||
# since cwd is set to project_dir
|
||||
security_settings = {
|
||||
"sandbox": {"enabled": True, "autoAllowBashIfSandboxed": True},
|
||||
"permissions": {
|
||||
"defaultMode": "acceptEdits", # Auto-approve edits within allowed directories
|
||||
"allow": [
|
||||
# Allow all file operations within the project directory
|
||||
# Include both relative (./**) and absolute paths for compatibility
|
||||
"Read(./**)",
|
||||
"Write(./**)",
|
||||
"Edit(./**)",
|
||||
"Glob(./**)",
|
||||
"Grep(./**)",
|
||||
# Also allow absolute paths (Claude sometimes uses full paths)
|
||||
f"Read({project_path_str}/**)",
|
||||
f"Write({project_path_str}/**)",
|
||||
f"Edit({project_path_str}/**)",
|
||||
f"Glob({project_path_str}/**)",
|
||||
f"Grep({project_path_str}/**)",
|
||||
# Bash permission granted here, but actual commands are validated
|
||||
# by the bash_security_hook (see security.py for allowed commands)
|
||||
"Bash(*)",
|
||||
# Allow web tools for documentation and research
|
||||
"WebFetch(*)",
|
||||
"WebSearch(*)",
|
||||
# Allow MCP tools based on required servers
|
||||
# Format: tool_name(*) allows all arguments
|
||||
*(
|
||||
[f"{tool}(*)" for tool in CONTEXT7_TOOLS]
|
||||
if "context7" in required_servers
|
||||
else []
|
||||
),
|
||||
*(
|
||||
[f"{tool}(*)" for tool in LINEAR_TOOLS]
|
||||
if "linear" in required_servers
|
||||
else []
|
||||
),
|
||||
*(
|
||||
[f"{tool}(*)" for tool in GRAPHITI_MCP_TOOLS]
|
||||
if graphiti_mcp_enabled
|
||||
else []
|
||||
),
|
||||
*[f"{tool}(*)" for tool in browser_tools_permissions],
|
||||
# Allow Context7 MCP tools for documentation lookup
|
||||
*CONTEXT7_TOOLS,
|
||||
# Allow Linear MCP tools for project management (if enabled)
|
||||
*(LINEAR_TOOLS if linear_enabled else []),
|
||||
# Allow Graphiti MCP tools for knowledge graph memory (if enabled)
|
||||
*(GRAPHITI_MCP_TOOLS if graphiti_mcp_enabled else []),
|
||||
# Allow browser automation tools based on project type
|
||||
*browser_tools_permissions,
|
||||
],
|
||||
},
|
||||
}
|
||||
@@ -242,26 +260,24 @@ def create_client(
|
||||
else:
|
||||
print(" - Extended thinking: disabled")
|
||||
|
||||
# Build list of MCP servers for display based on required_servers
|
||||
mcp_servers_list = []
|
||||
if "context7" in required_servers:
|
||||
mcp_servers_list.append("context7 (documentation)")
|
||||
if "electron" in required_servers:
|
||||
mcp_servers_list.append(
|
||||
f"electron (desktop automation, port {get_electron_debug_port()})"
|
||||
)
|
||||
if "puppeteer" in required_servers:
|
||||
mcp_servers_list.append("puppeteer (browser automation)")
|
||||
if "linear" in required_servers:
|
||||
# Build list of MCP servers for display
|
||||
mcp_servers_list = ["context7 (documentation)"]
|
||||
if agent_type in ("qa_reviewer", "qa_fixer"):
|
||||
if project_capabilities.get("is_electron") and electron_mcp_enabled:
|
||||
mcp_servers_list.append(
|
||||
f"electron (desktop automation, port {get_electron_debug_port()})"
|
||||
)
|
||||
elif project_capabilities.get(
|
||||
"is_web_frontend"
|
||||
) and not project_capabilities.get("is_electron"):
|
||||
mcp_servers_list.append("puppeteer (browser automation)")
|
||||
if linear_enabled:
|
||||
mcp_servers_list.append("linear (project management)")
|
||||
if graphiti_mcp_enabled:
|
||||
mcp_servers_list.append("graphiti-memory (knowledge graph)")
|
||||
if "auto-claude" in required_servers and auto_claude_tools_enabled:
|
||||
if auto_claude_tools_enabled:
|
||||
mcp_servers_list.append(f"auto-claude ({agent_type} tools)")
|
||||
if mcp_servers_list:
|
||||
print(f" - MCP servers: {', '.join(mcp_servers_list)}")
|
||||
else:
|
||||
print(" - MCP servers: none (minimal configuration)")
|
||||
print(f" - MCP servers: {', '.join(mcp_servers_list)}")
|
||||
|
||||
# Show detected project capabilities for QA agents
|
||||
if agent_type in ("qa_reviewer", "qa_fixer") and any(project_capabilities.values()):
|
||||
@@ -273,96 +289,76 @@ def create_client(
|
||||
print(f" - Project capabilities: {', '.join(caps)}")
|
||||
print()
|
||||
|
||||
# Configure MCP servers - ONLY start servers that are required
|
||||
# This is the key optimization to reduce context bloat and startup latency
|
||||
mcp_servers = {}
|
||||
# Configure MCP servers
|
||||
mcp_servers = {
|
||||
"context7": {"command": "npx", "args": ["-y", "@upstash/context7-mcp"]},
|
||||
}
|
||||
|
||||
if "context7" in required_servers:
|
||||
mcp_servers["context7"] = {
|
||||
"command": "npx",
|
||||
"args": ["-y", "@upstash/context7-mcp"],
|
||||
}
|
||||
# Add browser automation MCP server based on project type
|
||||
if agent_type in ("qa_reviewer", "qa_fixer"):
|
||||
if project_capabilities.get("is_electron") and electron_mcp_enabled:
|
||||
# Electron MCP for desktop apps
|
||||
# Electron app must be started with --remote-debugging-port=<port>
|
||||
mcp_servers["electron"] = {
|
||||
"command": "npm",
|
||||
"args": ["exec", "electron-mcp-server"],
|
||||
}
|
||||
elif project_capabilities.get(
|
||||
"is_web_frontend"
|
||||
) and not project_capabilities.get("is_electron"):
|
||||
# Puppeteer for web frontends (not Electron)
|
||||
mcp_servers["puppeteer"] = {
|
||||
"command": "npx",
|
||||
"args": ["puppeteer-mcp-server"],
|
||||
}
|
||||
|
||||
if "electron" in required_servers:
|
||||
# Electron MCP for desktop apps
|
||||
# Electron app must be started with --remote-debugging-port=<port>
|
||||
mcp_servers["electron"] = {
|
||||
"command": "npm",
|
||||
"args": ["exec", "electron-mcp-server"],
|
||||
}
|
||||
|
||||
if "puppeteer" in required_servers:
|
||||
# Puppeteer for web frontends (not Electron)
|
||||
mcp_servers["puppeteer"] = {
|
||||
"command": "npx",
|
||||
"args": ["puppeteer-mcp-server"],
|
||||
}
|
||||
|
||||
if "linear" in required_servers:
|
||||
# Add Linear MCP server if enabled
|
||||
if linear_enabled:
|
||||
mcp_servers["linear"] = {
|
||||
"type": "http",
|
||||
"url": "https://mcp.linear.app/mcp",
|
||||
"headers": {"Authorization": f"Bearer {linear_api_key}"},
|
||||
}
|
||||
|
||||
# Graphiti MCP server for knowledge graph memory
|
||||
# Add Graphiti MCP server if enabled
|
||||
# Graphiti MCP server for knowledge graph memory (uses embedded LadybugDB)
|
||||
if graphiti_mcp_enabled:
|
||||
mcp_servers["graphiti-memory"] = {
|
||||
"type": "http",
|
||||
"url": get_graphiti_mcp_url(),
|
||||
}
|
||||
|
||||
# Add custom auto-claude MCP server if required and available
|
||||
if "auto-claude" in required_servers and auto_claude_tools_enabled:
|
||||
# Add custom auto-claude MCP server if available
|
||||
auto_claude_mcp_server = None
|
||||
if auto_claude_tools_enabled:
|
||||
auto_claude_mcp_server = create_auto_claude_mcp_server(spec_dir, project_dir)
|
||||
if auto_claude_mcp_server:
|
||||
mcp_servers["auto-claude"] = auto_claude_mcp_server
|
||||
|
||||
# Build system prompt
|
||||
base_prompt = (
|
||||
f"You are an expert full-stack developer building production-quality software. "
|
||||
f"Your working directory is: {project_dir.resolve()}\n"
|
||||
f"Your filesystem access is RESTRICTED to this directory only. "
|
||||
f"Use relative paths (starting with ./) for all file operations. "
|
||||
f"Never use absolute paths or try to access files outside your working directory.\n\n"
|
||||
f"You follow existing code patterns, write clean maintainable code, and verify "
|
||||
f"your work through thorough testing. You communicate progress through Git commits "
|
||||
f"and build-progress.txt updates."
|
||||
return ClaudeSDKClient(
|
||||
options=ClaudeAgentOptions(
|
||||
model=model,
|
||||
system_prompt=(
|
||||
f"You are an expert full-stack developer building production-quality software. "
|
||||
f"Your working directory is: {project_dir.resolve()}\n"
|
||||
f"Your filesystem access is RESTRICTED to this directory only. "
|
||||
f"Use relative paths (starting with ./) for all file operations. "
|
||||
f"Never use absolute paths or try to access files outside your working directory.\n\n"
|
||||
f"You follow existing code patterns, write clean maintainable code, and verify "
|
||||
f"your work through thorough testing. You communicate progress through Git commits "
|
||||
f"and build-progress.txt updates."
|
||||
),
|
||||
allowed_tools=allowed_tools_list,
|
||||
mcp_servers=mcp_servers,
|
||||
hooks={
|
||||
"PreToolUse": [
|
||||
HookMatcher(matcher="Bash", hooks=[bash_security_hook]),
|
||||
],
|
||||
},
|
||||
max_turns=1000,
|
||||
cwd=str(project_dir.resolve()),
|
||||
settings=str(settings_file.resolve()),
|
||||
env=sdk_env, # Pass ANTHROPIC_BASE_URL etc. to subprocess
|
||||
max_thinking_tokens=max_thinking_tokens, # Extended thinking budget
|
||||
)
|
||||
)
|
||||
|
||||
# Include CLAUDE.md if enabled and present
|
||||
if should_use_claude_md():
|
||||
claude_md_content = load_claude_md(project_dir)
|
||||
if claude_md_content:
|
||||
base_prompt = f"{base_prompt}\n\n# Project Instructions (from CLAUDE.md)\n\n{claude_md_content}"
|
||||
print(" - CLAUDE.md: included in system prompt")
|
||||
else:
|
||||
print(" - CLAUDE.md: not found in project root")
|
||||
else:
|
||||
print(" - CLAUDE.md: disabled by project settings")
|
||||
print()
|
||||
|
||||
# Build options dict, conditionally including output_format
|
||||
options_kwargs = {
|
||||
"model": model,
|
||||
"system_prompt": base_prompt,
|
||||
"allowed_tools": allowed_tools_list,
|
||||
"mcp_servers": mcp_servers,
|
||||
"hooks": {
|
||||
"PreToolUse": [
|
||||
HookMatcher(matcher="Bash", hooks=[bash_security_hook]),
|
||||
],
|
||||
},
|
||||
"max_turns": 1000,
|
||||
"cwd": str(project_dir.resolve()),
|
||||
"settings": str(settings_file.resolve()),
|
||||
"env": sdk_env, # Pass ANTHROPIC_BASE_URL etc. to subprocess
|
||||
"max_thinking_tokens": max_thinking_tokens, # Extended thinking budget
|
||||
}
|
||||
|
||||
# Add structured output format if specified
|
||||
# See: https://platform.claude.com/docs/en/agent-sdk/structured-outputs
|
||||
if output_format:
|
||||
options_kwargs["output_format"] = output_format
|
||||
|
||||
return ClaudeSDKClient(options=ClaudeAgentOptions(**options_kwargs))
|
||||
|
||||
@@ -1,55 +0,0 @@
|
||||
"""
|
||||
Execution phase event protocol for frontend synchronization.
|
||||
|
||||
Protocol: __EXEC_PHASE__:{"phase":"coding","message":"Starting"}
|
||||
"""
|
||||
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
from enum import Enum
|
||||
from typing import Any
|
||||
|
||||
PHASE_MARKER_PREFIX = "__EXEC_PHASE__:"
|
||||
_DEBUG = os.environ.get("DEBUG", "").lower() in ("1", "true", "yes")
|
||||
|
||||
|
||||
class ExecutionPhase(str, Enum):
|
||||
"""Maps to frontend's ExecutionPhase type for task card badges."""
|
||||
|
||||
PLANNING = "planning"
|
||||
CODING = "coding"
|
||||
QA_REVIEW = "qa_review"
|
||||
QA_FIXING = "qa_fixing"
|
||||
COMPLETE = "complete"
|
||||
FAILED = "failed"
|
||||
|
||||
|
||||
def emit_phase(
|
||||
phase: ExecutionPhase | str,
|
||||
message: str = "",
|
||||
*,
|
||||
progress: int | None = None,
|
||||
subtask: str | None = None,
|
||||
) -> None:
|
||||
"""Emit structured phase event to stdout for frontend parsing."""
|
||||
phase_value = phase.value if isinstance(phase, ExecutionPhase) else phase
|
||||
|
||||
payload: dict[str, Any] = {
|
||||
"phase": phase_value,
|
||||
"message": message,
|
||||
}
|
||||
|
||||
if progress is not None:
|
||||
if not (0 <= progress <= 100):
|
||||
progress = max(0, min(100, progress))
|
||||
payload["progress"] = progress
|
||||
|
||||
if subtask is not None:
|
||||
payload["subtask"] = subtask
|
||||
|
||||
try:
|
||||
print(f"{PHASE_MARKER_PREFIX}{json.dumps(payload, default=str)}", flush=True)
|
||||
except (OSError, UnicodeEncodeError) as e:
|
||||
if _DEBUG:
|
||||
print(f"[phase_event] emit failed: {e}", file=sys.stderr, flush=True)
|
||||
@@ -1,97 +0,0 @@
|
||||
"""
|
||||
Simple Claude SDK Client Factory
|
||||
================================
|
||||
|
||||
Factory for creating minimal Claude SDK clients for single-turn utility operations
|
||||
like commit message generation, merge conflict resolution, and batch analysis.
|
||||
|
||||
These clients don't need full security configurations, MCP servers, or hooks.
|
||||
Use `create_client()` from `core.client` for full agent sessions with security.
|
||||
|
||||
Example usage:
|
||||
from core.simple_client import create_simple_client
|
||||
|
||||
# For commit message generation (text-only, no tools)
|
||||
client = create_simple_client(agent_type="commit_message")
|
||||
|
||||
# For merge conflict resolution (text-only, no tools)
|
||||
client = create_simple_client(agent_type="merge_resolver")
|
||||
|
||||
# For insights extraction (read tools only)
|
||||
client = create_simple_client(agent_type="insights", cwd=project_dir)
|
||||
"""
|
||||
|
||||
from pathlib import Path
|
||||
|
||||
from agents.tools_pkg import get_agent_config, get_default_thinking_level
|
||||
from claude_agent_sdk import ClaudeAgentOptions, ClaudeSDKClient
|
||||
from core.auth import get_sdk_env_vars, require_auth_token
|
||||
from phase_config import get_thinking_budget
|
||||
|
||||
|
||||
def create_simple_client(
|
||||
agent_type: str = "merge_resolver",
|
||||
model: str = "claude-haiku-4-5-20251001",
|
||||
system_prompt: str | None = None,
|
||||
cwd: Path | None = None,
|
||||
max_turns: int = 1,
|
||||
max_thinking_tokens: int | None = None,
|
||||
) -> ClaudeSDKClient:
|
||||
"""
|
||||
Create a minimal Claude SDK client for single-turn utility operations.
|
||||
|
||||
This factory creates lightweight clients without MCP servers, security hooks,
|
||||
or full permission configurations. Use for text-only analysis tasks.
|
||||
|
||||
Args:
|
||||
agent_type: Agent type from AGENT_CONFIGS. Determines available tools.
|
||||
Common utility types:
|
||||
- "merge_resolver" - Text-only merge conflict analysis
|
||||
- "commit_message" - Text-only commit message generation
|
||||
- "insights" - Read-only code insight extraction
|
||||
- "batch_analysis" - Read-only batch issue analysis
|
||||
- "batch_validation" - Read-only validation
|
||||
model: Claude model to use (defaults to Haiku for fast/cheap operations)
|
||||
system_prompt: Optional custom system prompt (for specialized tasks)
|
||||
cwd: Working directory for file operations (optional)
|
||||
max_turns: Maximum conversation turns (default: 1 for single-turn)
|
||||
max_thinking_tokens: Override thinking budget (None = use agent default from
|
||||
AGENT_CONFIGS, converted using phase_config.THINKING_BUDGET_MAP)
|
||||
|
||||
Returns:
|
||||
Configured ClaudeSDKClient for single-turn operations
|
||||
|
||||
Raises:
|
||||
ValueError: If agent_type is not found in AGENT_CONFIGS
|
||||
"""
|
||||
# Get authentication
|
||||
oauth_token = require_auth_token()
|
||||
import os
|
||||
|
||||
os.environ["CLAUDE_CODE_OAUTH_TOKEN"] = oauth_token
|
||||
|
||||
# Get environment variables for SDK
|
||||
sdk_env = get_sdk_env_vars()
|
||||
|
||||
# Get agent configuration (raises ValueError if unknown type)
|
||||
config = get_agent_config(agent_type)
|
||||
|
||||
# Get tools from config (no MCP tools for simple clients)
|
||||
allowed_tools = list(config.get("tools", []))
|
||||
|
||||
# Determine thinking budget using the single source of truth (phase_config.py)
|
||||
if max_thinking_tokens is None:
|
||||
thinking_level = get_default_thinking_level(agent_type)
|
||||
max_thinking_tokens = get_thinking_budget(thinking_level)
|
||||
|
||||
return ClaudeSDKClient(
|
||||
options=ClaudeAgentOptions(
|
||||
model=model,
|
||||
system_prompt=system_prompt,
|
||||
allowed_tools=allowed_tools,
|
||||
max_turns=max_turns,
|
||||
cwd=str(cwd.resolve()) if cwd else None,
|
||||
env=sdk_env,
|
||||
max_thinking_tokens=max_thinking_tokens,
|
||||
)
|
||||
)
|
||||
+38
-243
@@ -84,12 +84,6 @@ from core.workspace.git_utils import (
|
||||
_is_auto_claude_file,
|
||||
get_existing_build_worktree,
|
||||
)
|
||||
from core.workspace.git_utils import (
|
||||
apply_path_mapping as _apply_path_mapping,
|
||||
)
|
||||
from core.workspace.git_utils import (
|
||||
detect_file_renames as _detect_file_renames,
|
||||
)
|
||||
from core.workspace.git_utils import (
|
||||
get_changed_files_from_branch as _get_changed_files_from_branch,
|
||||
)
|
||||
@@ -99,9 +93,6 @@ from core.workspace.git_utils import (
|
||||
from core.workspace.git_utils import (
|
||||
is_lock_file as _is_lock_file,
|
||||
)
|
||||
from core.workspace.git_utils import (
|
||||
validate_merged_syntax as _validate_merged_syntax,
|
||||
)
|
||||
|
||||
# Import from refactored modules in core/workspace/
|
||||
from core.workspace.models import (
|
||||
@@ -239,15 +230,12 @@ def merge_existing_build(
|
||||
if smart_result is not None:
|
||||
# Smart merge handled it (success or identified conflicts)
|
||||
if smart_result.get("success"):
|
||||
# Check if smart merge resolved git conflicts or path-mapped files
|
||||
# Check if smart merge resolved git conflicts directly
|
||||
stats = smart_result.get("stats", {})
|
||||
had_conflicts = stats.get("conflicts_resolved", 0) > 0
|
||||
files_merged = stats.get("files_merged", 0) > 0
|
||||
ai_assisted = stats.get("ai_assisted", 0) > 0
|
||||
|
||||
if had_conflicts or files_merged or ai_assisted:
|
||||
# Git conflicts were resolved OR path-mapped files were AI merged
|
||||
# Changes are already written and staged - no need for git merge
|
||||
if had_conflicts:
|
||||
# Git conflicts were resolved (via AI or lock file exclusion) - changes are already staged
|
||||
_print_merge_success(
|
||||
no_commit, stats, spec_name=spec_name, keep_worktree=True
|
||||
)
|
||||
@@ -258,7 +246,7 @@ def merge_existing_build(
|
||||
|
||||
return True
|
||||
else:
|
||||
# No conflicts and no files merged - do standard git merge
|
||||
# No git conflicts, do standard git merge
|
||||
success_result = manager.merge_worktree(
|
||||
spec_name, delete_after=False, no_commit=no_commit
|
||||
)
|
||||
@@ -743,23 +731,6 @@ def _resolve_git_conflicts_with_ai(
|
||||
merge_base=merge_base[:12] if merge_base else None,
|
||||
)
|
||||
|
||||
# Detect file renames between merge-base and target branch
|
||||
# This handles cases where files were moved/renamed (e.g., directory restructures)
|
||||
path_mappings: dict[str, str] = {}
|
||||
if merge_base:
|
||||
path_mappings = _detect_file_renames(project_dir, merge_base, base_branch)
|
||||
if path_mappings:
|
||||
debug(
|
||||
MODULE,
|
||||
f"Detected {len(path_mappings)} file renames between merge-base and target",
|
||||
sample_mappings=dict(list(path_mappings.items())[:5]),
|
||||
)
|
||||
print(
|
||||
muted(
|
||||
f" Detected {len(path_mappings)} file rename(s) since branch creation"
|
||||
)
|
||||
)
|
||||
|
||||
# FIX: Copy NEW files FIRST before resolving conflicts
|
||||
# This ensures dependencies exist before files that import them are written
|
||||
changed_files = _get_changed_files_from_branch(
|
||||
@@ -777,24 +748,14 @@ def _resolve_git_conflicts_with_ai(
|
||||
project_dir, spec_branch, file_path
|
||||
)
|
||||
if content is not None:
|
||||
# Apply path mapping - write to new location if file was renamed
|
||||
target_file_path = _apply_path_mapping(file_path, path_mappings)
|
||||
target_path = project_dir / target_file_path
|
||||
target_path = project_dir / file_path
|
||||
target_path.parent.mkdir(parents=True, exist_ok=True)
|
||||
target_path.write_text(content, encoding="utf-8")
|
||||
subprocess.run(
|
||||
["git", "add", target_file_path],
|
||||
cwd=project_dir,
|
||||
capture_output=True,
|
||||
["git", "add", file_path], cwd=project_dir, capture_output=True
|
||||
)
|
||||
resolved_files.append(target_file_path)
|
||||
if target_file_path != file_path:
|
||||
debug(
|
||||
MODULE,
|
||||
f"Copied new file with path mapping: {file_path} -> {target_file_path}",
|
||||
)
|
||||
else:
|
||||
debug(MODULE, f"Copied new file: {file_path}")
|
||||
resolved_files.append(file_path)
|
||||
debug(MODULE, f"Copied new file: {file_path}")
|
||||
except Exception as e:
|
||||
debug_warning(MODULE, f"Could not copy new file {file_path}: {e}")
|
||||
|
||||
@@ -808,26 +769,20 @@ def _resolve_git_conflicts_with_ai(
|
||||
debug(MODULE, "Categorizing conflicting files for parallel processing")
|
||||
|
||||
for file_path in conflicting_files:
|
||||
# Apply path mapping to get the target path in the current branch
|
||||
target_file_path = _apply_path_mapping(file_path, path_mappings)
|
||||
debug(
|
||||
MODULE,
|
||||
f"Categorizing conflicting file: {file_path}"
|
||||
+ (f" -> {target_file_path}" if target_file_path != file_path else ""),
|
||||
)
|
||||
debug(MODULE, f"Categorizing conflicting file: {file_path}")
|
||||
|
||||
try:
|
||||
# Get content from main branch using MAPPED path (file may have been renamed)
|
||||
# Get content from main branch
|
||||
main_content = _get_file_content_from_ref(
|
||||
project_dir, base_branch, target_file_path
|
||||
project_dir, base_branch, file_path
|
||||
)
|
||||
|
||||
# Get content from worktree branch using ORIGINAL path
|
||||
# Get content from worktree branch
|
||||
worktree_content = _get_file_content_from_ref(
|
||||
project_dir, spec_branch, file_path
|
||||
)
|
||||
|
||||
# Get content from merge-base (common ancestor) using ORIGINAL path
|
||||
# Get content from merge-base (common ancestor)
|
||||
base_content = None
|
||||
if merge_base:
|
||||
base_content = _get_file_content_from_ref(
|
||||
@@ -840,49 +795,38 @@ def _resolve_git_conflicts_with_ai(
|
||||
|
||||
if main_content is None:
|
||||
# File only exists in worktree - it's a new file (no AI needed)
|
||||
# Write to target path (mapped if applicable)
|
||||
simple_merges.append((target_file_path, worktree_content))
|
||||
simple_merges.append((file_path, worktree_content))
|
||||
debug(MODULE, f" {file_path}: new file (no AI needed)")
|
||||
elif worktree_content is None:
|
||||
# File only exists in main - was deleted in worktree (no AI needed)
|
||||
simple_merges.append((target_file_path, None)) # None = delete
|
||||
simple_merges.append((file_path, None)) # None = delete
|
||||
debug(MODULE, f" {file_path}: deleted (no AI needed)")
|
||||
else:
|
||||
# File exists in both - check if it's a lock file
|
||||
if _is_lock_file(target_file_path):
|
||||
if _is_lock_file(file_path):
|
||||
# Lock files should be excluded from merge entirely
|
||||
# They must be regenerated after merge by running the package manager
|
||||
# (e.g., npm install, pnpm install, uv sync, cargo update)
|
||||
#
|
||||
# Strategy: Take main branch version and let user regenerate
|
||||
lock_files_excluded.append(target_file_path)
|
||||
simple_merges.append((target_file_path, main_content))
|
||||
lock_files_excluded.append(file_path)
|
||||
simple_merges.append((file_path, main_content))
|
||||
debug(
|
||||
MODULE,
|
||||
f" {target_file_path}: lock file (excluded - will use main version)",
|
||||
f" {file_path}: lock file (excluded - will use main version)",
|
||||
)
|
||||
else:
|
||||
# Regular file - needs AI merge
|
||||
# Store the TARGET path for writing, but track original for content retrieval
|
||||
files_needing_ai_merge.append(
|
||||
ParallelMergeTask(
|
||||
file_path=target_file_path, # Use target path for writing
|
||||
file_path=file_path,
|
||||
main_content=main_content,
|
||||
worktree_content=worktree_content,
|
||||
base_content=base_content,
|
||||
spec_name=spec_name,
|
||||
project_dir=project_dir,
|
||||
)
|
||||
)
|
||||
debug(
|
||||
MODULE,
|
||||
f" {file_path}: needs AI merge"
|
||||
+ (
|
||||
f" (will write to {target_file_path})"
|
||||
if target_file_path != file_path
|
||||
else ""
|
||||
),
|
||||
)
|
||||
debug(MODULE, f" {file_path}: needs AI merge")
|
||||
|
||||
except Exception as e:
|
||||
print(error(f" ✗ Failed to categorize {file_path}: {e}"))
|
||||
@@ -1002,140 +946,29 @@ def _resolve_git_conflicts_with_ai(
|
||||
if f not in conflicting_files and s != "A" # Skip new files, already copied
|
||||
]
|
||||
|
||||
# Separate files that need AI merge (path-mapped) from simple copies
|
||||
path_mapped_files: list[ParallelMergeTask] = []
|
||||
simple_copy_files: list[
|
||||
tuple[str, str, str]
|
||||
] = [] # (file_path, target_path, status)
|
||||
|
||||
for file_path, status in non_conflicting:
|
||||
# Apply path mapping for renamed/moved files
|
||||
target_file_path = _apply_path_mapping(file_path, path_mappings)
|
||||
|
||||
if target_file_path != file_path and status != "D":
|
||||
# File was renamed/moved - needs AI merge to incorporate changes
|
||||
# Get content from worktree (old path) and target branch (new path)
|
||||
worktree_content = _get_file_content_from_ref(
|
||||
project_dir, spec_branch, file_path
|
||||
)
|
||||
target_content = _get_file_content_from_ref(
|
||||
project_dir, base_branch, target_file_path
|
||||
)
|
||||
base_content = None
|
||||
if merge_base:
|
||||
base_content = _get_file_content_from_ref(
|
||||
project_dir, merge_base, file_path
|
||||
)
|
||||
|
||||
if worktree_content and target_content:
|
||||
# Both exist - need AI merge
|
||||
path_mapped_files.append(
|
||||
ParallelMergeTask(
|
||||
file_path=target_file_path,
|
||||
main_content=target_content,
|
||||
worktree_content=worktree_content,
|
||||
base_content=base_content,
|
||||
spec_name=spec_name,
|
||||
project_dir=project_dir,
|
||||
)
|
||||
)
|
||||
debug(
|
||||
MODULE,
|
||||
f"Path-mapped file needs AI merge: {file_path} -> {target_file_path}",
|
||||
)
|
||||
elif worktree_content:
|
||||
# Only exists in worktree - simple copy to new path
|
||||
simple_copy_files.append((file_path, target_file_path, status))
|
||||
else:
|
||||
# No path mapping or deletion - simple operation
|
||||
simple_copy_files.append((file_path, target_file_path, status))
|
||||
|
||||
# Process path-mapped files with AI merge
|
||||
if path_mapped_files:
|
||||
print()
|
||||
print_status(
|
||||
f"Merging {len(path_mapped_files)} path-mapped file(s) with AI...",
|
||||
"progress",
|
||||
)
|
||||
|
||||
import time
|
||||
|
||||
start_time = time.time()
|
||||
|
||||
# Run parallel merges for path-mapped files
|
||||
path_mapped_results = asyncio.run(
|
||||
_run_parallel_merges(
|
||||
tasks=path_mapped_files,
|
||||
project_dir=project_dir,
|
||||
max_concurrent=MAX_PARALLEL_AI_MERGES,
|
||||
)
|
||||
)
|
||||
|
||||
elapsed = time.time() - start_time
|
||||
|
||||
for result in path_mapped_results:
|
||||
if result.success:
|
||||
target_path = project_dir / result.file_path
|
||||
target_path.parent.mkdir(parents=True, exist_ok=True)
|
||||
target_path.write_text(result.merged_content, encoding="utf-8")
|
||||
subprocess.run(
|
||||
["git", "add", result.file_path],
|
||||
cwd=project_dir,
|
||||
capture_output=True,
|
||||
)
|
||||
resolved_files.append(result.file_path)
|
||||
|
||||
if result.was_auto_merged:
|
||||
auto_merged_count += 1
|
||||
print(success(f" ✓ {result.file_path} (auto-merged)"))
|
||||
else:
|
||||
ai_merged_count += 1
|
||||
print(success(f" ✓ {result.file_path} (AI merged)"))
|
||||
else:
|
||||
print(error(f" ✗ {result.file_path}: {result.error}"))
|
||||
remaining_conflicts.append(
|
||||
{
|
||||
"file": result.file_path,
|
||||
"reason": result.error or "AI could not merge path-mapped file",
|
||||
"severity": "high",
|
||||
}
|
||||
)
|
||||
|
||||
print(muted(f" Path-mapped merge completed in {elapsed:.1f}s"))
|
||||
|
||||
# Process simple copy/delete files
|
||||
for file_path, target_file_path, status in simple_copy_files:
|
||||
try:
|
||||
if status == "D":
|
||||
# Deleted in worktree - delete from target path
|
||||
target_path = project_dir / target_file_path
|
||||
# Deleted in worktree
|
||||
target_path = project_dir / file_path
|
||||
if target_path.exists():
|
||||
target_path.unlink()
|
||||
subprocess.run(
|
||||
["git", "add", target_file_path],
|
||||
cwd=project_dir,
|
||||
capture_output=True,
|
||||
["git", "add", file_path], cwd=project_dir, capture_output=True
|
||||
)
|
||||
else:
|
||||
# Modified without path change - simple copy
|
||||
# Added or modified - copy from worktree
|
||||
content = _get_file_content_from_ref(
|
||||
project_dir, spec_branch, file_path
|
||||
)
|
||||
if content is not None:
|
||||
target_path = project_dir / target_file_path
|
||||
target_path = project_dir / file_path
|
||||
target_path.parent.mkdir(parents=True, exist_ok=True)
|
||||
target_path.write_text(content, encoding="utf-8")
|
||||
subprocess.run(
|
||||
["git", "add", target_file_path],
|
||||
cwd=project_dir,
|
||||
capture_output=True,
|
||||
["git", "add", file_path], cwd=project_dir, capture_output=True
|
||||
)
|
||||
resolved_files.append(target_file_path)
|
||||
if target_file_path != file_path:
|
||||
debug(
|
||||
MODULE,
|
||||
f"Merged with path mapping: {file_path} -> {target_file_path}",
|
||||
)
|
||||
resolved_files.append(file_path)
|
||||
except Exception as e:
|
||||
print(muted(f" Warning: Could not process {file_path}: {e}"))
|
||||
|
||||
@@ -1407,20 +1240,23 @@ async def _merge_file_with_ai_async(
|
||||
|
||||
# Call Claude Haiku for fast merge
|
||||
try:
|
||||
from core.simple_client import create_simple_client
|
||||
from claude_agent_sdk import ClaudeAgentOptions, ClaudeSDKClient
|
||||
except ImportError:
|
||||
return ParallelMergeResult(
|
||||
file_path=task.file_path,
|
||||
merged_content=None,
|
||||
success=False,
|
||||
error="core.simple_client not available",
|
||||
error="claude_agent_sdk not installed",
|
||||
)
|
||||
|
||||
client = create_simple_client(
|
||||
agent_type="merge_resolver",
|
||||
model="claude-haiku-4-5-20251001",
|
||||
system_prompt=AI_MERGE_SYSTEM_PROMPT,
|
||||
max_thinking_tokens=1024, # Low thinking for speed
|
||||
client = ClaudeSDKClient(
|
||||
options=ClaudeAgentOptions(
|
||||
model="claude-haiku-4-5-20251001",
|
||||
system_prompt=AI_MERGE_SYSTEM_PROMPT,
|
||||
allowed_tools=[],
|
||||
max_turns=1,
|
||||
max_thinking_tokens=1024, # Low thinking for speed
|
||||
)
|
||||
)
|
||||
|
||||
response_text = ""
|
||||
@@ -1438,47 +1274,6 @@ async def _merge_file_with_ai_async(
|
||||
# Strip any code fences the model might have added
|
||||
merged_content = _strip_code_fences(response_text.strip())
|
||||
|
||||
# VALIDATION: Check if AI returned natural language instead of code
|
||||
# This catches cases where AI says "I need to see more..." instead of merging
|
||||
natural_language_patterns = [
|
||||
"I need to",
|
||||
"Let me",
|
||||
"I cannot",
|
||||
"I'm unable",
|
||||
"The file appears",
|
||||
"I don't have",
|
||||
"Unfortunately",
|
||||
"I apologize",
|
||||
]
|
||||
first_line = merged_content.split("\n")[0] if merged_content else ""
|
||||
if any(pattern in first_line for pattern in natural_language_patterns):
|
||||
debug_warning(
|
||||
MODULE,
|
||||
f"AI returned natural language instead of code for {task.file_path}: {first_line[:100]}",
|
||||
)
|
||||
return ParallelMergeResult(
|
||||
file_path=task.file_path,
|
||||
merged_content=None,
|
||||
success=False,
|
||||
error=f"AI returned explanation instead of code: {first_line[:80]}...",
|
||||
)
|
||||
|
||||
# VALIDATION: Run syntax check on the merged content
|
||||
is_valid, syntax_error = _validate_merged_syntax(
|
||||
task.file_path, merged_content, task.project_dir
|
||||
)
|
||||
if not is_valid:
|
||||
debug_warning(
|
||||
MODULE,
|
||||
f"AI merge produced invalid syntax for {task.file_path}: {syntax_error}",
|
||||
)
|
||||
return ParallelMergeResult(
|
||||
file_path=task.file_path,
|
||||
merged_content=None,
|
||||
success=False,
|
||||
error=f"AI merge produced invalid syntax: {syntax_error}",
|
||||
)
|
||||
|
||||
debug(MODULE, f"AI merged {task.file_path} successfully")
|
||||
return ParallelMergeResult(
|
||||
file_path=task.file_path,
|
||||
|
||||
@@ -83,111 +83,6 @@ MERGE_LOCK_TIMEOUT = 300 # 5 minutes
|
||||
MAX_SYNTAX_FIX_RETRIES = 2
|
||||
|
||||
|
||||
def detect_file_renames(
|
||||
project_dir: Path,
|
||||
from_ref: str,
|
||||
to_ref: str,
|
||||
) -> dict[str, str]:
|
||||
"""
|
||||
Detect file renames between two git refs using git's rename detection.
|
||||
|
||||
This analyzes the commit history between two refs to find all file
|
||||
renames/moves. Critical for merging changes from older branches that
|
||||
used a different directory structure.
|
||||
|
||||
Uses git's -M flag for rename detection with high similarity threshold.
|
||||
|
||||
Args:
|
||||
project_dir: Project directory
|
||||
from_ref: Starting ref (e.g., merge-base commit or old branch)
|
||||
to_ref: Target ref (e.g., current branch HEAD)
|
||||
|
||||
Returns:
|
||||
Dict mapping old_path -> new_path for all renamed files
|
||||
"""
|
||||
renames: dict[str, str] = {}
|
||||
|
||||
try:
|
||||
# Use git log with rename detection to find all renames between refs
|
||||
# -M flag enables rename detection
|
||||
# --diff-filter=R shows only renames
|
||||
# --name-status shows status and file names
|
||||
result = subprocess.run(
|
||||
[
|
||||
"git",
|
||||
"log",
|
||||
"--name-status",
|
||||
"-M",
|
||||
"--diff-filter=R",
|
||||
"--format=", # No commit info, just file changes
|
||||
f"{from_ref}..{to_ref}",
|
||||
],
|
||||
cwd=project_dir,
|
||||
capture_output=True,
|
||||
text=True,
|
||||
)
|
||||
|
||||
if result.returncode == 0:
|
||||
for line in result.stdout.strip().split("\n"):
|
||||
if line.startswith("R"):
|
||||
# Format: R100\told_path\tnew_path (tab-separated)
|
||||
parts = line.split("\t")
|
||||
if len(parts) >= 3:
|
||||
old_path = parts[1]
|
||||
new_path = parts[2]
|
||||
renames[old_path] = new_path
|
||||
|
||||
except Exception:
|
||||
pass # Return empty dict on error
|
||||
|
||||
return renames
|
||||
|
||||
|
||||
def apply_path_mapping(file_path: str, mappings: dict[str, str]) -> str:
|
||||
"""
|
||||
Apply file path mappings to get the new path for a file.
|
||||
|
||||
Args:
|
||||
file_path: Original file path (from older branch)
|
||||
mappings: Dict of old_path -> new_path from detect_file_renames
|
||||
|
||||
Returns:
|
||||
Mapped new path if found, otherwise original path
|
||||
"""
|
||||
# Direct match
|
||||
if file_path in mappings:
|
||||
return mappings[file_path]
|
||||
|
||||
# No mapping found
|
||||
return file_path
|
||||
|
||||
|
||||
def get_merge_base(project_dir: Path, ref1: str, ref2: str) -> str | None:
|
||||
"""
|
||||
Get the merge-base commit between two refs.
|
||||
|
||||
Args:
|
||||
project_dir: Project directory
|
||||
ref1: First ref (branch/commit)
|
||||
ref2: Second ref (branch/commit)
|
||||
|
||||
Returns:
|
||||
Merge-base commit hash, or None if not found
|
||||
"""
|
||||
try:
|
||||
result = subprocess.run(
|
||||
["git", "merge-base", ref1, ref2],
|
||||
cwd=project_dir,
|
||||
capture_output=True,
|
||||
text=True,
|
||||
)
|
||||
if result.returncode == 0:
|
||||
return result.stdout.strip()
|
||||
except Exception:
|
||||
pass
|
||||
return None
|
||||
|
||||
|
||||
def has_uncommitted_changes(project_dir: Path) -> bool:
|
||||
"""Check if user has unsaved work."""
|
||||
result = subprocess.run(
|
||||
|
||||
@@ -36,7 +36,6 @@ class ParallelMergeTask:
|
||||
worktree_content: str
|
||||
base_content: str | None
|
||||
spec_name: str
|
||||
project_dir: Path
|
||||
|
||||
|
||||
@dataclass
|
||||
@@ -135,141 +134,3 @@ class MergeLock:
|
||||
self.lock_file.unlink()
|
||||
except Exception:
|
||||
pass # Best effort cleanup
|
||||
|
||||
|
||||
class SpecNumberLockError(Exception):
|
||||
"""Raised when a spec number lock cannot be acquired."""
|
||||
|
||||
pass
|
||||
|
||||
|
||||
class SpecNumberLock:
|
||||
"""
|
||||
Context manager for spec number coordination across main project and worktrees.
|
||||
|
||||
Prevents race conditions when creating specs by:
|
||||
1. Acquiring an exclusive file lock
|
||||
2. Scanning ALL spec locations (main + worktrees)
|
||||
3. Finding global maximum spec number
|
||||
4. Allowing atomic spec directory creation
|
||||
5. Releasing lock
|
||||
"""
|
||||
|
||||
def __init__(self, project_dir: Path):
|
||||
self.project_dir = project_dir
|
||||
self.lock_dir = project_dir / ".auto-claude" / ".locks"
|
||||
self.lock_file = self.lock_dir / "spec-numbering.lock"
|
||||
self.acquired = False
|
||||
self._global_max: int | None = None
|
||||
|
||||
def __enter__(self) -> "SpecNumberLock":
|
||||
"""Acquire the spec numbering lock."""
|
||||
import os
|
||||
import time
|
||||
|
||||
self.lock_dir.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
max_wait = 30 # seconds
|
||||
start_time = time.time()
|
||||
|
||||
while True:
|
||||
try:
|
||||
# Try to create lock file exclusively (atomic operation)
|
||||
fd = os.open(
|
||||
str(self.lock_file),
|
||||
os.O_CREAT | os.O_EXCL | os.O_WRONLY,
|
||||
0o644,
|
||||
)
|
||||
os.close(fd)
|
||||
|
||||
# Write our PID to the lock file
|
||||
self.lock_file.write_text(str(os.getpid()))
|
||||
self.acquired = True
|
||||
return self
|
||||
|
||||
except FileExistsError:
|
||||
# Lock file exists - check if process is still running
|
||||
if self.lock_file.exists():
|
||||
try:
|
||||
pid = int(self.lock_file.read_text().strip())
|
||||
import os as _os
|
||||
|
||||
try:
|
||||
_os.kill(pid, 0)
|
||||
is_running = True
|
||||
except (OSError, ProcessLookupError):
|
||||
is_running = False
|
||||
|
||||
if not is_running:
|
||||
# Stale lock - remove it
|
||||
self.lock_file.unlink()
|
||||
continue
|
||||
except (ValueError, ProcessLookupError):
|
||||
# Invalid PID or can't check - remove stale lock
|
||||
self.lock_file.unlink()
|
||||
continue
|
||||
|
||||
# Active lock - wait or timeout
|
||||
if time.time() - start_time >= max_wait:
|
||||
raise SpecNumberLockError(
|
||||
f"Could not acquire spec numbering lock after {max_wait}s"
|
||||
)
|
||||
|
||||
time.sleep(0.1) # Shorter sleep for spec creation
|
||||
|
||||
def __exit__(self, exc_type, exc_val, exc_tb):
|
||||
"""Release the spec numbering lock."""
|
||||
if self.acquired and self.lock_file.exists():
|
||||
try:
|
||||
self.lock_file.unlink()
|
||||
except Exception:
|
||||
pass # Best effort cleanup
|
||||
|
||||
def get_next_spec_number(self) -> int:
|
||||
"""
|
||||
Scan all spec locations and return the next available spec number.
|
||||
|
||||
Must be called while lock is held.
|
||||
|
||||
Returns:
|
||||
Next available spec number (global max + 1)
|
||||
"""
|
||||
if not self.acquired:
|
||||
raise SpecNumberLockError(
|
||||
"Lock must be acquired before getting next spec number"
|
||||
)
|
||||
|
||||
if self._global_max is not None:
|
||||
return self._global_max + 1
|
||||
|
||||
max_number = 0
|
||||
|
||||
# 1. Scan main project specs
|
||||
main_specs_dir = self.project_dir / ".auto-claude" / "specs"
|
||||
max_number = max(max_number, self._scan_specs_dir(main_specs_dir))
|
||||
|
||||
# 2. Scan all worktree specs
|
||||
worktrees_dir = self.project_dir / ".worktrees"
|
||||
if worktrees_dir.exists():
|
||||
for worktree in worktrees_dir.iterdir():
|
||||
if worktree.is_dir():
|
||||
worktree_specs = worktree / ".auto-claude" / "specs"
|
||||
max_number = max(max_number, self._scan_specs_dir(worktree_specs))
|
||||
|
||||
self._global_max = max_number
|
||||
return max_number + 1
|
||||
|
||||
def _scan_specs_dir(self, specs_dir: Path) -> int:
|
||||
"""Scan a specs directory and return the highest spec number found."""
|
||||
if not specs_dir.exists():
|
||||
return 0
|
||||
|
||||
max_num = 0
|
||||
for folder in specs_dir.glob("[0-9][0-9][0-9]-*"):
|
||||
try:
|
||||
num = int(folder.name[:3])
|
||||
max_num = max(max_num, num)
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
return max_num
|
||||
|
||||
@@ -143,43 +143,6 @@ def choose_workspace(
|
||||
return WorkspaceMode.ISOLATED
|
||||
|
||||
|
||||
def copy_env_files_to_worktree(project_dir: Path, worktree_path: Path) -> list[str]:
|
||||
"""
|
||||
Copy .env files from project root to worktree (without overwriting).
|
||||
|
||||
This ensures the worktree has access to environment variables needed
|
||||
to run the project (e.g., API keys, database URLs).
|
||||
|
||||
Args:
|
||||
project_dir: The main project directory
|
||||
worktree_path: Path to the worktree
|
||||
|
||||
Returns:
|
||||
List of copied file names
|
||||
"""
|
||||
copied = []
|
||||
# Common .env file patterns - copy if they exist
|
||||
env_patterns = [
|
||||
".env",
|
||||
".env.local",
|
||||
".env.development",
|
||||
".env.development.local",
|
||||
".env.test",
|
||||
".env.test.local",
|
||||
]
|
||||
|
||||
for pattern in env_patterns:
|
||||
env_file = project_dir / pattern
|
||||
if env_file.is_file():
|
||||
target = worktree_path / pattern
|
||||
if not target.exists():
|
||||
shutil.copy2(env_file, target)
|
||||
copied.append(pattern)
|
||||
debug(MODULE, f"Copied {pattern} to worktree")
|
||||
|
||||
return copied
|
||||
|
||||
|
||||
def copy_spec_to_worktree(
|
||||
source_spec_dir: Path,
|
||||
worktree_path: Path,
|
||||
@@ -260,13 +223,6 @@ def setup_workspace(
|
||||
# Get or create worktree for THIS SPECIFIC SPEC
|
||||
worktree_info = manager.get_or_create_worktree(spec_name)
|
||||
|
||||
# Copy .env files to worktree so user can run the project
|
||||
copied_env_files = copy_env_files_to_worktree(project_dir, worktree_info.path)
|
||||
if copied_env_files:
|
||||
print_status(
|
||||
f"Environment files copied: {', '.join(copied_env_files)}", "success"
|
||||
)
|
||||
|
||||
# Copy spec files to worktree if provided
|
||||
localized_spec_dir = None
|
||||
if source_spec_dir and source_spec_dir.exists():
|
||||
|
||||
@@ -0,0 +1,168 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Implementation Plan Manager
|
||||
============================
|
||||
|
||||
DEPRECATED: This module is now a compatibility shim. The implementation has been
|
||||
refactored into the implementation_plan/ package for better modularity.
|
||||
|
||||
Please import from the package directly:
|
||||
from implementation_plan import ImplementationPlan, Subtask, Phase, etc.
|
||||
|
||||
This file re-exports all public APIs for backwards compatibility.
|
||||
|
||||
Core data structures and utilities for subtask-based implementation plans.
|
||||
Replaces the test-centric feature_list.json with implementation_plan.json.
|
||||
|
||||
The key insight: Tests verify outcomes, but SUBTASKS define implementation steps.
|
||||
For complex multi-service features, implementation order matters.
|
||||
|
||||
Workflow Types:
|
||||
- feature: Standard multi-service feature (phases = services)
|
||||
- refactor: Migration/refactor work (phases = stages: add, migrate, remove)
|
||||
- investigation: Bug hunting (phases = investigate, hypothesize, fix)
|
||||
- migration: Data migration (phases = prepare, test, execute, cleanup)
|
||||
- simple: Single-service enhancement (minimal overhead)
|
||||
"""
|
||||
|
||||
# Re-export everything from the implementation_plan package
|
||||
from implementation_plan import (
|
||||
Chunk,
|
||||
ChunkStatus,
|
||||
ImplementationPlan,
|
||||
Phase,
|
||||
PhaseType,
|
||||
Subtask,
|
||||
SubtaskStatus,
|
||||
Verification,
|
||||
VerificationType,
|
||||
WorkflowType,
|
||||
create_feature_plan,
|
||||
create_investigation_plan,
|
||||
create_refactor_plan,
|
||||
)
|
||||
|
||||
__all__ = [
|
||||
# Enums
|
||||
"WorkflowType",
|
||||
"PhaseType",
|
||||
"SubtaskStatus",
|
||||
"VerificationType",
|
||||
# Models
|
||||
"Verification",
|
||||
"Subtask",
|
||||
"Phase",
|
||||
"ImplementationPlan",
|
||||
# Factories
|
||||
"create_feature_plan",
|
||||
"create_investigation_plan",
|
||||
"create_refactor_plan",
|
||||
# Backwards compatibility
|
||||
"Chunk",
|
||||
"ChunkStatus",
|
||||
]
|
||||
|
||||
|
||||
# CLI for testing
|
||||
if __name__ == "__main__":
|
||||
import json
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
if len(sys.argv) < 2:
|
||||
print("Usage: python implementation_plan.py <plan.json>")
|
||||
print(" python implementation_plan.py --demo")
|
||||
sys.exit(1)
|
||||
|
||||
if sys.argv[1] == "--demo":
|
||||
# Create a demo plan
|
||||
plan = create_feature_plan(
|
||||
feature="Avatar Upload with Processing",
|
||||
services=["backend", "worker", "frontend"],
|
||||
phases_config=[
|
||||
{
|
||||
"name": "Backend Foundation",
|
||||
"parallel_safe": True,
|
||||
"subtasks": [
|
||||
{
|
||||
"id": "avatar-model",
|
||||
"service": "backend",
|
||||
"description": "Add avatar fields to User model",
|
||||
"files_to_modify": ["app/models/user.py"],
|
||||
"files_to_create": ["migrations/add_avatar.py"],
|
||||
"verification": {
|
||||
"type": "command",
|
||||
"run": "flask db upgrade",
|
||||
},
|
||||
},
|
||||
{
|
||||
"id": "avatar-endpoint",
|
||||
"service": "backend",
|
||||
"description": "POST /api/users/avatar endpoint",
|
||||
"files_to_modify": ["app/routes/users.py"],
|
||||
"patterns_from": ["app/routes/profile.py"],
|
||||
"verification": {
|
||||
"type": "api",
|
||||
"method": "POST",
|
||||
"url": "/api/users/avatar",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
"name": "Worker Pipeline",
|
||||
"depends_on": [1],
|
||||
"subtasks": [
|
||||
{
|
||||
"id": "image-task",
|
||||
"service": "worker",
|
||||
"description": "Celery task for image processing",
|
||||
"files_to_create": ["app/tasks/images.py"],
|
||||
"patterns_from": ["app/tasks/reports.py"],
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
"name": "Frontend",
|
||||
"depends_on": [1],
|
||||
"subtasks": [
|
||||
{
|
||||
"id": "avatar-component",
|
||||
"service": "frontend",
|
||||
"description": "AvatarUpload React component",
|
||||
"files_to_create": ["src/components/AvatarUpload.tsx"],
|
||||
"patterns_from": ["src/components/FileUpload.tsx"],
|
||||
},
|
||||
],
|
||||
},
|
||||
{
|
||||
"name": "Integration",
|
||||
"depends_on": [2, 3],
|
||||
"type": "integration",
|
||||
"subtasks": [
|
||||
{
|
||||
"id": "e2e-wiring",
|
||||
"all_services": True,
|
||||
"description": "Connect frontend → backend → worker",
|
||||
"verification": {
|
||||
"type": "browser",
|
||||
"scenario": "Upload → Process → Display",
|
||||
},
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
)
|
||||
plan.final_acceptance = [
|
||||
"User can upload avatar from profile page",
|
||||
"Avatar is automatically resized",
|
||||
"Large/invalid files show error",
|
||||
]
|
||||
|
||||
print(json.dumps(plan.to_dict(), indent=2))
|
||||
print("\n---\n")
|
||||
print(plan.get_status_summary())
|
||||
else:
|
||||
# Load and display existing plan
|
||||
plan = ImplementationPlan.load(Path(sys.argv[1]))
|
||||
print(plan.get_status_summary())
|
||||
@@ -8,8 +8,8 @@ Follows the same patterns as linear_config.py for consistency.
|
||||
Uses LadybugDB as the embedded graph database (no Docker required, requires Python 3.12+).
|
||||
|
||||
Multi-Provider Support (V2):
|
||||
- LLM Providers: OpenAI, Anthropic, Azure OpenAI, Ollama, Google AI, OpenRouter
|
||||
- Embedder Providers: OpenAI, Voyage AI, Azure OpenAI, Ollama, Google AI, OpenRouter
|
||||
- LLM Providers: OpenAI, Anthropic, Azure OpenAI, Ollama, Google AI
|
||||
- Embedder Providers: OpenAI, Voyage AI, Azure OpenAI, Ollama, Google AI
|
||||
|
||||
Environment Variables:
|
||||
# Core
|
||||
@@ -89,7 +89,6 @@ class LLMProvider(str, Enum):
|
||||
AZURE_OPENAI = "azure_openai"
|
||||
OLLAMA = "ollama"
|
||||
GOOGLE = "google"
|
||||
OPENROUTER = "openrouter"
|
||||
|
||||
|
||||
class EmbedderProvider(str, Enum):
|
||||
@@ -100,7 +99,6 @@ class EmbedderProvider(str, Enum):
|
||||
AZURE_OPENAI = "azure_openai"
|
||||
OLLAMA = "ollama"
|
||||
GOOGLE = "google"
|
||||
OPENROUTER = "openrouter"
|
||||
|
||||
|
||||
@dataclass
|
||||
@@ -143,12 +141,6 @@ class GraphitiConfig:
|
||||
google_llm_model: str = "gemini-2.0-flash"
|
||||
google_embedding_model: str = "text-embedding-004"
|
||||
|
||||
# OpenRouter settings (multi-provider aggregator)
|
||||
openrouter_api_key: str = ""
|
||||
openrouter_base_url: str = "https://openrouter.ai/api/v1"
|
||||
openrouter_llm_model: str = "anthropic/claude-3.5-sonnet"
|
||||
openrouter_embedding_model: str = "openai/text-embedding-3-small"
|
||||
|
||||
# Ollama settings (local)
|
||||
ollama_base_url: str = DEFAULT_OLLAMA_BASE_URL
|
||||
ollama_llm_model: str = ""
|
||||
@@ -204,18 +196,6 @@ class GraphitiConfig:
|
||||
"GOOGLE_EMBEDDING_MODEL", "text-embedding-004"
|
||||
)
|
||||
|
||||
# OpenRouter settings
|
||||
openrouter_api_key = os.environ.get("OPENROUTER_API_KEY", "")
|
||||
openrouter_base_url = os.environ.get(
|
||||
"OPENROUTER_BASE_URL", "https://openrouter.ai/api/v1"
|
||||
)
|
||||
openrouter_llm_model = os.environ.get(
|
||||
"OPENROUTER_LLM_MODEL", "anthropic/claude-3.5-sonnet"
|
||||
)
|
||||
openrouter_embedding_model = os.environ.get(
|
||||
"OPENROUTER_EMBEDDING_MODEL", "openai/text-embedding-3-small"
|
||||
)
|
||||
|
||||
# Ollama settings
|
||||
ollama_base_url = os.environ.get("OLLAMA_BASE_URL", DEFAULT_OLLAMA_BASE_URL)
|
||||
ollama_llm_model = os.environ.get("OLLAMA_LLM_MODEL", "")
|
||||
@@ -247,10 +227,6 @@ class GraphitiConfig:
|
||||
google_api_key=google_api_key,
|
||||
google_llm_model=google_llm_model,
|
||||
google_embedding_model=google_embedding_model,
|
||||
openrouter_api_key=openrouter_api_key,
|
||||
openrouter_base_url=openrouter_base_url,
|
||||
openrouter_llm_model=openrouter_llm_model,
|
||||
openrouter_embedding_model=openrouter_embedding_model,
|
||||
ollama_base_url=ollama_base_url,
|
||||
ollama_llm_model=ollama_llm_model,
|
||||
ollama_embedding_model=ollama_embedding_model,
|
||||
@@ -291,8 +267,6 @@ class GraphitiConfig:
|
||||
return bool(self.ollama_embedding_model)
|
||||
elif self.embedder_provider == "google":
|
||||
return bool(self.google_api_key)
|
||||
elif self.embedder_provider == "openrouter":
|
||||
return bool(self.openrouter_api_key)
|
||||
return False
|
||||
|
||||
def get_validation_errors(self) -> list[str]:
|
||||
@@ -335,11 +309,6 @@ class GraphitiConfig:
|
||||
elif self.embedder_provider == "google":
|
||||
if not self.google_api_key:
|
||||
errors.append("Google embedder provider requires GOOGLE_API_KEY")
|
||||
elif self.embedder_provider == "openrouter":
|
||||
if not self.openrouter_api_key:
|
||||
errors.append(
|
||||
"OpenRouter embedder provider requires OPENROUTER_API_KEY"
|
||||
)
|
||||
else:
|
||||
errors.append(f"Unknown embedder provider: {self.embedder_provider}")
|
||||
|
||||
@@ -398,18 +367,6 @@ class GraphitiConfig:
|
||||
elif self.embedder_provider == "azure_openai":
|
||||
# Depends on the deployment, default to 1536
|
||||
return 1536
|
||||
elif self.embedder_provider == "openrouter":
|
||||
# OpenRouter uses provider/model format
|
||||
# Extract underlying provider to determine dimension
|
||||
model = self.openrouter_embedding_model.lower()
|
||||
if model.startswith("openai/"):
|
||||
return 1536 # OpenAI text-embedding-3-small
|
||||
elif model.startswith("voyage/"):
|
||||
return 1024 # Voyage-3
|
||||
elif model.startswith("google/"):
|
||||
return 768 # Google text-embedding-004
|
||||
# Add more providers as needed
|
||||
return 1536 # Default for unknown OpenRouter models
|
||||
return 768 # Safe default
|
||||
|
||||
def get_provider_signature(self) -> str:
|
||||
@@ -446,14 +403,7 @@ class GraphitiConfig:
|
||||
base_name = self.database
|
||||
|
||||
# Remove existing provider suffix if present
|
||||
for provider in [
|
||||
"openai",
|
||||
"ollama",
|
||||
"voyage",
|
||||
"google",
|
||||
"azure_openai",
|
||||
"openrouter",
|
||||
]:
|
||||
for provider in ["openai", "ollama", "voyage", "google", "azure_openai"]:
|
||||
if f"_{provider}_" in base_name:
|
||||
base_name = base_name.split(f"_{provider}_")[0]
|
||||
break
|
||||
@@ -667,11 +617,6 @@ def get_available_providers() -> dict:
|
||||
available_llm.append("google")
|
||||
available_embedder.append("google")
|
||||
|
||||
# Check OpenRouter
|
||||
if config.openrouter_api_key:
|
||||
available_llm.append("openrouter")
|
||||
available_embedder.append("openrouter")
|
||||
|
||||
# Check Ollama
|
||||
if config.ollama_llm_model:
|
||||
available_llm.append("ollama")
|
||||
|
||||
@@ -18,7 +18,6 @@ from .ollama_embedder import (
|
||||
get_embedding_dim_for_model,
|
||||
)
|
||||
from .openai_embedder import create_openai_embedder
|
||||
from .openrouter_embedder import create_openrouter_embedder
|
||||
from .voyage_embedder import create_voyage_embedder
|
||||
|
||||
__all__ = [
|
||||
@@ -27,7 +26,6 @@ __all__ = [
|
||||
"create_azure_openai_embedder",
|
||||
"create_ollama_embedder",
|
||||
"create_google_embedder",
|
||||
"create_openrouter_embedder",
|
||||
"KNOWN_OLLAMA_EMBEDDING_MODELS",
|
||||
"get_embedding_dim_for_model",
|
||||
]
|
||||
|
||||
+3
-3
@@ -94,9 +94,6 @@ def create_ollama_embedder(config: "GraphitiConfig") -> Any:
|
||||
ProviderNotInstalled: If graphiti-core is not installed
|
||||
ProviderError: If model is not specified
|
||||
"""
|
||||
if not config.ollama_embedding_model:
|
||||
raise ProviderError("Ollama embedder requires OLLAMA_EMBEDDING_MODEL")
|
||||
|
||||
try:
|
||||
from graphiti_core.embedder.openai import OpenAIEmbedder, OpenAIEmbedderConfig
|
||||
except ImportError as e:
|
||||
@@ -106,6 +103,9 @@ def create_ollama_embedder(config: "GraphitiConfig") -> Any:
|
||||
f"Error: {e}"
|
||||
)
|
||||
|
||||
if not config.ollama_embedding_model:
|
||||
raise ProviderError("Ollama embedder requires OLLAMA_EMBEDDING_MODEL")
|
||||
|
||||
# Get embedding dimension (auto-detect for known models, or use configured value)
|
||||
embedding_dim = get_embedding_dim_for_model(
|
||||
config.ollama_embedding_model,
|
||||
|
||||
-60
@@ -1,60 +0,0 @@
|
||||
"""
|
||||
OpenRouter Embedder Provider
|
||||
=============================
|
||||
|
||||
OpenRouter embedder implementation for Graphiti.
|
||||
Uses OpenAI-compatible embedding API.
|
||||
"""
|
||||
|
||||
from typing import TYPE_CHECKING, Any
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from ...config import GraphitiConfig
|
||||
|
||||
from ..exceptions import ProviderError, ProviderNotInstalled
|
||||
|
||||
|
||||
def create_openrouter_embedder(config: "GraphitiConfig") -> Any:
|
||||
"""
|
||||
Create OpenRouter embedder client.
|
||||
|
||||
OpenRouter uses OpenAI-compatible API, so we use the OpenAI embedder
|
||||
with custom base URL.
|
||||
|
||||
Args:
|
||||
config: GraphitiConfig with OpenRouter settings
|
||||
|
||||
Returns:
|
||||
OpenAI-compatible embedder instance
|
||||
|
||||
Raises:
|
||||
ProviderNotInstalled: If graphiti-core is not installed
|
||||
ProviderError: If API key is missing
|
||||
|
||||
Example:
|
||||
>>> from auto_claude.integrations.graphiti.config import GraphitiConfig
|
||||
>>> config = GraphitiConfig(
|
||||
... openrouter_api_key="sk-or-...",
|
||||
... openrouter_embedding_model="openai/text-embedding-3-small"
|
||||
... )
|
||||
>>> embedder = create_openrouter_embedder(config)
|
||||
"""
|
||||
try:
|
||||
from graphiti_core.embedder import EmbedderConfig, OpenAIEmbedder
|
||||
except ImportError as e:
|
||||
raise ProviderNotInstalled(
|
||||
f"OpenRouter provider requires graphiti-core. "
|
||||
f"Install with: pip install graphiti-core\n"
|
||||
f"Error: {e}"
|
||||
)
|
||||
|
||||
if not config.openrouter_api_key:
|
||||
raise ProviderError("OpenRouter provider requires OPENROUTER_API_KEY")
|
||||
|
||||
embedder_config = EmbedderConfig(
|
||||
api_key=config.openrouter_api_key,
|
||||
model=config.openrouter_embedding_model,
|
||||
base_url=config.openrouter_base_url,
|
||||
)
|
||||
|
||||
return OpenAIEmbedder(config=embedder_config)
|
||||
@@ -16,7 +16,6 @@ from .embedder_providers import (
|
||||
create_google_embedder,
|
||||
create_ollama_embedder,
|
||||
create_openai_embedder,
|
||||
create_openrouter_embedder,
|
||||
create_voyage_embedder,
|
||||
)
|
||||
from .exceptions import ProviderError
|
||||
@@ -26,7 +25,6 @@ from .llm_providers import (
|
||||
create_google_llm_client,
|
||||
create_ollama_llm_client,
|
||||
create_openai_llm_client,
|
||||
create_openrouter_llm_client,
|
||||
)
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
@@ -60,8 +58,6 @@ def create_llm_client(config: "GraphitiConfig") -> Any:
|
||||
return create_ollama_llm_client(config)
|
||||
elif provider == "google":
|
||||
return create_google_llm_client(config)
|
||||
elif provider == "openrouter":
|
||||
return create_openrouter_llm_client(config)
|
||||
else:
|
||||
raise ProviderError(f"Unknown LLM provider: {provider}")
|
||||
|
||||
@@ -94,7 +90,5 @@ def create_embedder(config: "GraphitiConfig") -> Any:
|
||||
return create_ollama_embedder(config)
|
||||
elif provider == "google":
|
||||
return create_google_embedder(config)
|
||||
elif provider == "openrouter":
|
||||
return create_openrouter_embedder(config)
|
||||
else:
|
||||
raise ProviderError(f"Unknown embedder provider: {provider}")
|
||||
|
||||
@@ -15,7 +15,6 @@ from .azure_openai_llm import create_azure_openai_llm_client
|
||||
from .google_llm import create_google_llm_client
|
||||
from .ollama_llm import create_ollama_llm_client
|
||||
from .openai_llm import create_openai_llm_client
|
||||
from .openrouter_llm import create_openrouter_llm_client
|
||||
|
||||
__all__ = [
|
||||
"create_openai_llm_client",
|
||||
@@ -23,5 +22,4 @@ __all__ = [
|
||||
"create_azure_openai_llm_client",
|
||||
"create_ollama_llm_client",
|
||||
"create_google_llm_client",
|
||||
"create_openrouter_llm_client",
|
||||
]
|
||||
|
||||
@@ -27,9 +27,6 @@ def create_openai_llm_client(config: "GraphitiConfig") -> Any:
|
||||
ProviderNotInstalled: If graphiti-core is not installed
|
||||
ProviderError: If API key is missing
|
||||
"""
|
||||
if not config.openai_api_key:
|
||||
raise ProviderError("OpenAI provider requires OPENAI_API_KEY")
|
||||
|
||||
try:
|
||||
from graphiti_core.llm_client.config import LLMConfig
|
||||
from graphiti_core.llm_client.openai_client import OpenAIClient
|
||||
@@ -40,6 +37,9 @@ def create_openai_llm_client(config: "GraphitiConfig") -> Any:
|
||||
f"Error: {e}"
|
||||
)
|
||||
|
||||
if not config.openai_api_key:
|
||||
raise ProviderError("OpenAI provider requires OPENAI_API_KEY")
|
||||
|
||||
llm_config = LLMConfig(
|
||||
api_key=config.openai_api_key,
|
||||
model=config.openai_model,
|
||||
|
||||
@@ -1,63 +0,0 @@
|
||||
"""
|
||||
OpenRouter LLM Provider
|
||||
=======================
|
||||
|
||||
OpenRouter LLM client implementation for Graphiti.
|
||||
Uses OpenAI-compatible API.
|
||||
"""
|
||||
|
||||
from typing import TYPE_CHECKING, Any
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from ...config import GraphitiConfig
|
||||
|
||||
from ..exceptions import ProviderError, ProviderNotInstalled
|
||||
|
||||
|
||||
def create_openrouter_llm_client(config: "GraphitiConfig") -> Any:
|
||||
"""
|
||||
Create OpenRouter LLM client.
|
||||
|
||||
OpenRouter uses OpenAI-compatible API, so we use the OpenAI client
|
||||
with custom base URL.
|
||||
|
||||
Args:
|
||||
config: GraphitiConfig with OpenRouter settings
|
||||
|
||||
Returns:
|
||||
OpenAI-compatible LLM client instance
|
||||
|
||||
Raises:
|
||||
ProviderNotInstalled: If graphiti-core is not installed
|
||||
ProviderError: If API key is missing
|
||||
|
||||
Example:
|
||||
>>> from auto_claude.integrations.graphiti.config import GraphitiConfig
|
||||
>>> config = GraphitiConfig(
|
||||
... openrouter_api_key="sk-or-...",
|
||||
... openrouter_llm_model="anthropic/claude-3.5-sonnet"
|
||||
... )
|
||||
>>> client = create_openrouter_llm_client(config)
|
||||
"""
|
||||
try:
|
||||
from graphiti_core.llm_client.config import LLMConfig
|
||||
from graphiti_core.llm_client.openai_client import OpenAIClient
|
||||
except ImportError as e:
|
||||
raise ProviderNotInstalled(
|
||||
f"OpenRouter provider requires graphiti-core. "
|
||||
f"Install with: pip install graphiti-core\n"
|
||||
f"Error: {e}"
|
||||
)
|
||||
|
||||
if not config.openrouter_api_key:
|
||||
raise ProviderError("OpenRouter provider requires OPENROUTER_API_KEY")
|
||||
|
||||
llm_config = LLMConfig(
|
||||
api_key=config.openrouter_api_key,
|
||||
model=config.openrouter_llm_model,
|
||||
base_url=config.openrouter_base_url,
|
||||
)
|
||||
|
||||
# OpenRouter uses OpenAI-compatible API
|
||||
# Disable reasoning/verbosity for compatibility
|
||||
return OpenAIClient(config=llm_config, reasoning=None, verbosity=None)
|
||||
@@ -146,12 +146,12 @@ class GraphitiClient:
|
||||
# The original graphiti-core KuzuDriver has build_indices_and_constraints()
|
||||
# as a no-op, which causes FTS search failures
|
||||
from integrations.graphiti.queries_pkg.kuzu_driver_patched import (
|
||||
create_patched_kuzu_driver,
|
||||
PatchedKuzuDriver as KuzuDriver,
|
||||
)
|
||||
|
||||
db_path = self.config.get_db_path()
|
||||
try:
|
||||
self._driver = create_patched_kuzu_driver(db=str(db_path))
|
||||
self._driver = KuzuDriver(db=str(db_path))
|
||||
except (OSError, PermissionError) as e:
|
||||
logger.warning(
|
||||
f"Failed to initialize LadybugDB driver at {db_path}: {e}"
|
||||
|
||||
@@ -108,7 +108,7 @@ class GraphitiMemory:
|
||||
if self.group_id_mode == GroupIdMode.PROJECT:
|
||||
project_name = self.project_dir.name
|
||||
path_hash = hashlib.md5(
|
||||
str(self.project_dir.resolve()).encode(), usedforsecurity=False
|
||||
str(self.project_dir.resolve()).encode()
|
||||
).hexdigest()[:8]
|
||||
return f"project_{project_name}_{path_hash}"
|
||||
else:
|
||||
|
||||
@@ -9,7 +9,6 @@ This patched driver fixes both issues for LadybugDB compatibility.
|
||||
"""
|
||||
|
||||
import logging
|
||||
import re
|
||||
from typing import Any
|
||||
|
||||
# Import kuzu (might be real_ladybug via monkeypatch)
|
||||
@@ -18,159 +17,157 @@ try:
|
||||
except ImportError:
|
||||
import real_ladybug as kuzu # type: ignore
|
||||
|
||||
from graphiti_core.driver.driver import GraphProvider
|
||||
from graphiti_core.driver.kuzu_driver import KuzuDriver as OriginalKuzuDriver
|
||||
from graphiti_core.graph_queries import get_fulltext_indices
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def create_patched_kuzu_driver(db: str = ":memory:", max_concurrent_queries: int = 1):
|
||||
from graphiti_core.driver.driver import GraphProvider
|
||||
from graphiti_core.driver.kuzu_driver import KuzuDriver as OriginalKuzuDriver
|
||||
from graphiti_core.graph_queries import get_fulltext_indices
|
||||
class PatchedKuzuDriver(OriginalKuzuDriver):
|
||||
"""
|
||||
KuzuDriver with proper FTS index creation and parameter handling.
|
||||
|
||||
class PatchedKuzuDriver(OriginalKuzuDriver):
|
||||
Fixes two bugs in graphiti-core:
|
||||
1. FTS indexes are never created (build_indices_and_constraints is a no-op)
|
||||
2. None parameters are filtered out, causing "Parameter not found" errors
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
db: str = ":memory:",
|
||||
max_concurrent_queries: int = 1,
|
||||
):
|
||||
# Store database path before calling parent (which creates the Database)
|
||||
self._database = db # Required by Graphiti for group_id checks
|
||||
super().__init__(db, max_concurrent_queries)
|
||||
|
||||
async def execute_query(
|
||||
self, cypher_query_: str, **kwargs: Any
|
||||
) -> tuple[list[dict[str, Any]] | list[list[dict[str, Any]]], None, None]:
|
||||
"""
|
||||
KuzuDriver with proper FTS index creation and parameter handling.
|
||||
Execute a Cypher query with proper None parameter handling.
|
||||
|
||||
Fixes two bugs in graphiti-core:
|
||||
1. FTS indexes are never created (build_indices_and_constraints is a no-op)
|
||||
2. None parameters are filtered out, causing "Parameter not found" errors
|
||||
The original driver filters out None values, but LadybugDB requires
|
||||
all referenced parameters to exist. This override keeps None values
|
||||
in the parameters dict.
|
||||
"""
|
||||
# Don't filter out None values - LadybugDB needs them
|
||||
params = {k: v for k, v in kwargs.items()}
|
||||
# Still remove these unsupported parameters
|
||||
params.pop("database_", None)
|
||||
params.pop("routing_", None)
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
db: str = ":memory:",
|
||||
max_concurrent_queries: int = 1,
|
||||
):
|
||||
# Store database path before calling parent (which creates the Database)
|
||||
self._database = db # Required by Graphiti for group_id checks
|
||||
super().__init__(db, max_concurrent_queries)
|
||||
try:
|
||||
results = await self.client.execute(cypher_query_, parameters=params)
|
||||
except Exception as e:
|
||||
# Truncate long values for logging
|
||||
log_params = {
|
||||
k: (v[:5] if isinstance(v, list) else v) for k, v in params.items()
|
||||
}
|
||||
logger.error(
|
||||
f"Error executing Kuzu query: {e}\n{cypher_query_}\n{log_params}"
|
||||
)
|
||||
raise
|
||||
|
||||
async def execute_query(
|
||||
self, cypher_query_: str, **kwargs: Any
|
||||
) -> tuple[list[dict[str, Any]] | list[list[dict[str, Any]]], None, None]:
|
||||
"""
|
||||
Execute a Cypher query with proper None parameter handling.
|
||||
if not results:
|
||||
return [], None, None
|
||||
|
||||
The original driver filters out None values, but LadybugDB requires
|
||||
all referenced parameters to exist. This override keeps None values
|
||||
in the parameters dict.
|
||||
"""
|
||||
# Don't filter out None values - LadybugDB needs them
|
||||
params = {k: v for k, v in kwargs.items()}
|
||||
# Still remove these unsupported parameters
|
||||
params.pop("database_", None)
|
||||
params.pop("routing_", None)
|
||||
if isinstance(results, list):
|
||||
dict_results = [list(result.rows_as_dict()) for result in results]
|
||||
else:
|
||||
dict_results = list(results.rows_as_dict())
|
||||
return dict_results, None, None # type: ignore
|
||||
|
||||
async def build_indices_and_constraints(self, delete_existing: bool = False):
|
||||
"""
|
||||
Build FTS indexes required for Graphiti's hybrid search.
|
||||
|
||||
The original KuzuDriver has this as a no-op, but we need to actually
|
||||
create the FTS indexes for search to work.
|
||||
|
||||
Args:
|
||||
delete_existing: If True, drop and recreate indexes (default: False)
|
||||
"""
|
||||
logger.info("Building FTS indexes for Kuzu/LadybugDB...")
|
||||
|
||||
# Get the FTS index creation queries from Graphiti
|
||||
fts_queries = get_fulltext_indices(GraphProvider.KUZU)
|
||||
|
||||
# Create a sync connection for index creation
|
||||
conn = kuzu.Connection(self.db)
|
||||
|
||||
try:
|
||||
for query in fts_queries:
|
||||
try:
|
||||
# Check if we need to drop existing index first
|
||||
if delete_existing:
|
||||
# Extract index name from query
|
||||
# Format: CALL CREATE_FTS_INDEX('TableName', 'index_name', [...])
|
||||
parts = query.split("'")
|
||||
if len(parts) >= 4:
|
||||
table_name = parts[1]
|
||||
index_name = parts[3]
|
||||
drop_query = (
|
||||
f"CALL DROP_FTS_INDEX('{table_name}', '{index_name}')"
|
||||
)
|
||||
try:
|
||||
conn.execute(drop_query)
|
||||
logger.debug(
|
||||
f"Dropped existing FTS index: {index_name}"
|
||||
)
|
||||
except Exception:
|
||||
# Index might not exist, that's fine
|
||||
pass
|
||||
|
||||
# Create the FTS index
|
||||
conn.execute(query)
|
||||
logger.debug(f"Created FTS index: {query[:80]}...")
|
||||
|
||||
except Exception as e:
|
||||
error_msg = str(e).lower()
|
||||
# Handle "index already exists" gracefully
|
||||
if "already exists" in error_msg or "duplicate" in error_msg:
|
||||
logger.debug(
|
||||
f"FTS index already exists (skipping): {query[:60]}..."
|
||||
)
|
||||
else:
|
||||
# Log but don't fail - some indexes might fail in certain Kuzu versions
|
||||
logger.warning(f"Failed to create FTS index: {e}")
|
||||
logger.debug(f"Query was: {query}")
|
||||
|
||||
logger.info("FTS indexes created successfully")
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
def setup_schema(self):
|
||||
"""
|
||||
Set up the database schema and install/load the FTS extension.
|
||||
|
||||
Extends the parent setup_schema() to properly set up FTS support.
|
||||
"""
|
||||
conn = kuzu.Connection(self.db)
|
||||
|
||||
try:
|
||||
# First, install the FTS extension (required before loading)
|
||||
try:
|
||||
results = await self.client.execute(cypher_query_, parameters=params)
|
||||
conn.execute("INSTALL fts")
|
||||
logger.debug("Installed FTS extension")
|
||||
except Exception as e:
|
||||
# Truncate long values for logging
|
||||
log_params = {
|
||||
k: (v[:5] if isinstance(v, list) else v) for k, v in params.items()
|
||||
}
|
||||
logger.error(
|
||||
f"Error executing Kuzu query: {e}\n{cypher_query_}\n{log_params}"
|
||||
)
|
||||
raise
|
||||
|
||||
if not results:
|
||||
return [], None, None
|
||||
|
||||
if isinstance(results, list):
|
||||
dict_results = [list(result.rows_as_dict()) for result in results]
|
||||
else:
|
||||
dict_results = list(results.rows_as_dict())
|
||||
return dict_results, None, None # type: ignore
|
||||
|
||||
async def build_indices_and_constraints(self, delete_existing: bool = False):
|
||||
"""
|
||||
Build FTS indexes required for Graphiti's hybrid search.
|
||||
|
||||
The original KuzuDriver has this as a no-op, but we need to actually
|
||||
create the FTS indexes for search to work.
|
||||
|
||||
Args:
|
||||
delete_existing: If True, drop and recreate indexes (default: False)
|
||||
"""
|
||||
logger.info("Building FTS indexes for Kuzu/LadybugDB...")
|
||||
|
||||
# Get the FTS index creation queries from Graphiti
|
||||
fts_queries = get_fulltext_indices(GraphProvider.KUZU)
|
||||
|
||||
# Create a sync connection for index creation
|
||||
conn = kuzu.Connection(self.db)
|
||||
error_msg = str(e).lower()
|
||||
if "already" not in error_msg:
|
||||
logger.debug(f"FTS extension install note: {e}")
|
||||
|
||||
# Then load the FTS extension
|
||||
try:
|
||||
for query in fts_queries:
|
||||
try:
|
||||
# Check if we need to drop existing index first
|
||||
if delete_existing:
|
||||
# Extract index name from query
|
||||
# Format: CALL CREATE_FTS_INDEX('TableName', 'index_name', [...])
|
||||
match = re.search(
|
||||
r"CREATE_FTS_INDEX\('([^']+)',\s*'([^']+)'", query
|
||||
)
|
||||
if match:
|
||||
table_name, index_name = match.groups()
|
||||
drop_query = f"CALL DROP_FTS_INDEX('{table_name}', '{index_name}')"
|
||||
try:
|
||||
conn.execute(drop_query)
|
||||
logger.debug(
|
||||
f"Dropped existing FTS index: {index_name}"
|
||||
)
|
||||
except Exception:
|
||||
# Index might not exist, that's fine
|
||||
pass
|
||||
conn.execute("LOAD EXTENSION fts")
|
||||
logger.debug("Loaded FTS extension")
|
||||
except Exception as e:
|
||||
error_msg = str(e).lower()
|
||||
if "already loaded" not in error_msg:
|
||||
logger.debug(f"FTS extension load note: {e}")
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
# Create the FTS index
|
||||
conn.execute(query)
|
||||
logger.debug(f"Created FTS index: {query[:80]}...")
|
||||
|
||||
except Exception as e:
|
||||
error_msg = str(e).lower()
|
||||
# Handle "index already exists" gracefully
|
||||
if "already exists" in error_msg or "duplicate" in error_msg:
|
||||
logger.debug(
|
||||
f"FTS index already exists (skipping): {query[:60]}..."
|
||||
)
|
||||
else:
|
||||
# Log but don't fail - some indexes might fail in certain Kuzu versions
|
||||
logger.warning(f"Failed to create FTS index: {e}")
|
||||
logger.debug(f"Query was: {query}")
|
||||
|
||||
logger.info("FTS indexes created successfully")
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
def setup_schema(self):
|
||||
"""
|
||||
Set up the database schema and install/load the FTS extension.
|
||||
|
||||
Extends the parent setup_schema() to properly set up FTS support.
|
||||
"""
|
||||
conn = kuzu.Connection(self.db)
|
||||
|
||||
try:
|
||||
# First, install the FTS extension (required before loading)
|
||||
try:
|
||||
conn.execute("INSTALL fts")
|
||||
logger.debug("Installed FTS extension")
|
||||
except Exception as e:
|
||||
error_msg = str(e).lower()
|
||||
if "already" not in error_msg:
|
||||
logger.debug(f"FTS extension install note: {e}")
|
||||
|
||||
# Then load the FTS extension
|
||||
try:
|
||||
conn.execute("LOAD EXTENSION fts")
|
||||
logger.debug("Loaded FTS extension")
|
||||
except Exception as e:
|
||||
error_msg = str(e).lower()
|
||||
if "already loaded" not in error_msg:
|
||||
logger.debug(f"FTS extension load note: {e}")
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
# Run the parent schema setup (creates tables)
|
||||
super().setup_schema()
|
||||
|
||||
return PatchedKuzuDriver(db=db, max_concurrent_queries=max_concurrent_queries)
|
||||
# Run the parent schema setup (creates tables)
|
||||
super().setup_schema()
|
||||
|
||||
@@ -75,7 +75,7 @@ class GraphitiSearch:
|
||||
if self.group_id_mode == GroupIdMode.SPEC and include_project_context:
|
||||
project_name = self.project_dir.name
|
||||
path_hash = hashlib.md5(
|
||||
str(self.project_dir.resolve()).encode(), usedforsecurity=False
|
||||
str(self.project_dir.resolve()).encode()
|
||||
).hexdigest()[:8]
|
||||
project_group_id = f"project_{project_name}_{path_hash}"
|
||||
if project_group_id != self.group_id:
|
||||
|
||||
@@ -1,862 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Test Script for Ollama Embedding Memory Integration
|
||||
====================================================
|
||||
|
||||
This test validates that the memory system works correctly with local Ollama
|
||||
embedding models (like embeddinggemma, nomic-embed-text) for creating and
|
||||
retrieving memories in the hybrid RAG system.
|
||||
|
||||
The test covers:
|
||||
1. Ollama embedding generation (direct API test)
|
||||
2. Creating memories with Ollama embeddings via GraphitiMemory
|
||||
3. Retrieving memories via semantic search
|
||||
4. Verifying the full create → store → retrieve cycle
|
||||
|
||||
Prerequisites:
|
||||
1. Install Ollama: https://ollama.ai/
|
||||
2. Pull an embedding model:
|
||||
ollama pull embeddinggemma # 768 dimensions (lightweight)
|
||||
ollama pull nomic-embed-text # 768 dimensions (good quality)
|
||||
3. Pull an LLM model (for knowledge graph construction):
|
||||
ollama pull deepseek-r1:7b # or llama3.2:3b, mistral:7b
|
||||
4. Start Ollama server: ollama serve
|
||||
5. Configure environment:
|
||||
export GRAPHITI_ENABLED=true
|
||||
export GRAPHITI_LLM_PROVIDER=ollama
|
||||
export GRAPHITI_EMBEDDER_PROVIDER=ollama
|
||||
export OLLAMA_LLM_MODEL=deepseek-r1:7b
|
||||
export OLLAMA_EMBEDDING_MODEL=embeddinggemma
|
||||
export OLLAMA_EMBEDDING_DIM=768
|
||||
|
||||
NOTE: graphiti-core internally uses an OpenAI reranker for search ranking.
|
||||
For full offline operation, set a dummy key: export OPENAI_API_KEY=dummy
|
||||
The reranker will fail at search time, but embedding creation works.
|
||||
For production, use OpenAI API key for best search quality.
|
||||
|
||||
Usage:
|
||||
cd apps/backend
|
||||
python integrations/graphiti/test_ollama_embedding_memory.py
|
||||
|
||||
# Run specific tests:
|
||||
python integrations/graphiti/test_ollama_embedding_memory.py --test embeddings
|
||||
python integrations/graphiti/test_ollama_embedding_memory.py --test create
|
||||
python integrations/graphiti/test_ollama_embedding_memory.py --test retrieve
|
||||
python integrations/graphiti/test_ollama_embedding_memory.py --test full-cycle
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import asyncio
|
||||
import os
|
||||
import shutil
|
||||
import sys
|
||||
import tempfile
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
|
||||
# Add auto-claude to path
|
||||
auto_claude_dir = Path(__file__).parent.parent.parent
|
||||
sys.path.insert(0, str(auto_claude_dir))
|
||||
|
||||
# Load .env file
|
||||
try:
|
||||
from dotenv import load_dotenv
|
||||
|
||||
env_file = auto_claude_dir / ".env"
|
||||
if env_file.exists():
|
||||
load_dotenv(env_file)
|
||||
print(f"Loaded .env from {env_file}")
|
||||
except ImportError:
|
||||
print("Note: python-dotenv not installed, using environment variables only")
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# Helper Functions
|
||||
# ============================================================================
|
||||
|
||||
|
||||
def print_header(title: str):
|
||||
"""Print a section header."""
|
||||
print("\n" + "=" * 70)
|
||||
print(f" {title}")
|
||||
print("=" * 70 + "\n")
|
||||
|
||||
|
||||
def print_result(label: str, value: str, success: bool = True):
|
||||
"""Print a result line."""
|
||||
status = "PASS" if success else "FAIL"
|
||||
print(f" [{status}] {label}: {value}")
|
||||
|
||||
|
||||
def print_info(message: str):
|
||||
"""Print an info line."""
|
||||
print(f" INFO: {message}")
|
||||
|
||||
|
||||
def print_step(step: int, message: str):
|
||||
"""Print a step indicator."""
|
||||
print(f"\n Step {step}: {message}")
|
||||
|
||||
|
||||
def apply_ladybug_monkeypatch():
|
||||
"""Apply LadybugDB monkeypatch for embedded database support."""
|
||||
try:
|
||||
import real_ladybug
|
||||
|
||||
sys.modules["kuzu"] = real_ladybug
|
||||
return True
|
||||
except ImportError:
|
||||
pass
|
||||
|
||||
# Try native kuzu as fallback
|
||||
try:
|
||||
import kuzu # noqa: F401
|
||||
|
||||
return True
|
||||
except ImportError:
|
||||
return False
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# Test 1: Ollama Embedding Generation
|
||||
# ============================================================================
|
||||
|
||||
|
||||
async def test_ollama_embeddings() -> bool:
|
||||
"""
|
||||
Test Ollama embedding generation directly via API.
|
||||
|
||||
This validates that Ollama is running and can generate embeddings
|
||||
with the configured model.
|
||||
"""
|
||||
print_header("Test 1: Ollama Embedding Generation")
|
||||
|
||||
ollama_model = os.environ.get("OLLAMA_EMBEDDING_MODEL", "embeddinggemma")
|
||||
ollama_base_url = os.environ.get("OLLAMA_BASE_URL", "http://localhost:11434")
|
||||
expected_dim = int(os.environ.get("OLLAMA_EMBEDDING_DIM", "768"))
|
||||
|
||||
print(f" Ollama Model: {ollama_model}")
|
||||
print(f" Base URL: {ollama_base_url}")
|
||||
print(f" Expected Dimension: {expected_dim}")
|
||||
print()
|
||||
|
||||
try:
|
||||
import requests
|
||||
except ImportError:
|
||||
print_result("requests library", "Not installed - pip install requests", False)
|
||||
return False
|
||||
|
||||
# Step 1: Check Ollama is running
|
||||
print_step(1, "Checking Ollama server status")
|
||||
try:
|
||||
resp = requests.get(f"{ollama_base_url}/api/tags", timeout=10)
|
||||
if resp.status_code != 200:
|
||||
print_result(
|
||||
"Ollama server",
|
||||
f"Not responding (status {resp.status_code})",
|
||||
False,
|
||||
)
|
||||
return False
|
||||
|
||||
models = resp.json().get("models", [])
|
||||
model_names = [m.get("name", "") for m in models]
|
||||
print_result("Ollama server", f"Running with {len(models)} models", True)
|
||||
|
||||
# Check if embedding model is available
|
||||
embedding_model_found = any(
|
||||
ollama_model in name or ollama_model.split(":")[0] in name
|
||||
for name in model_names
|
||||
)
|
||||
if not embedding_model_found:
|
||||
print_info(f"Model '{ollama_model}' not found. Available: {model_names}")
|
||||
print_info(f"Pull it with: ollama pull {ollama_model}")
|
||||
|
||||
except requests.exceptions.ConnectionError:
|
||||
print_result(
|
||||
"Ollama server",
|
||||
"Not running - start with 'ollama serve'",
|
||||
False,
|
||||
)
|
||||
return False
|
||||
|
||||
# Step 2: Generate test embedding
|
||||
print_step(2, "Generating test embeddings")
|
||||
|
||||
test_texts = [
|
||||
"This is a test memory about implementing OAuth authentication.",
|
||||
"The user prefers using TypeScript for frontend development.",
|
||||
"A gotcha discovered: always validate JWT tokens on the server side.",
|
||||
]
|
||||
|
||||
embeddings = []
|
||||
for i, text in enumerate(test_texts):
|
||||
resp = requests.post(
|
||||
f"{ollama_base_url}/api/embeddings",
|
||||
json={"model": ollama_model, "prompt": text},
|
||||
timeout=60,
|
||||
)
|
||||
|
||||
if resp.status_code != 200:
|
||||
print_result(
|
||||
f"Embedding {i + 1}",
|
||||
f"Failed: {resp.status_code} - {resp.text[:100]}",
|
||||
False,
|
||||
)
|
||||
return False
|
||||
|
||||
data = resp.json()
|
||||
embedding = data.get("embedding", [])
|
||||
embeddings.append(embedding)
|
||||
|
||||
print_result(
|
||||
f"Embedding {i + 1}",
|
||||
f"Generated {len(embedding)} dimensions",
|
||||
True,
|
||||
)
|
||||
|
||||
# Step 3: Validate embedding dimensions
|
||||
print_step(3, "Validating embedding dimensions")
|
||||
|
||||
for i, embedding in enumerate(embeddings):
|
||||
if len(embedding) != expected_dim:
|
||||
print_result(
|
||||
f"Embedding {i + 1} dimension",
|
||||
f"Mismatch! Got {len(embedding)}, expected {expected_dim}",
|
||||
False,
|
||||
)
|
||||
print_info(f"Update OLLAMA_EMBEDDING_DIM={len(embedding)} in your config")
|
||||
return False
|
||||
print_result(
|
||||
f"Embedding {i + 1} dimension", f"{len(embedding)} matches expected", True
|
||||
)
|
||||
|
||||
# Step 4: Test embedding similarity (basic sanity check)
|
||||
print_step(4, "Testing embedding similarity")
|
||||
|
||||
def cosine_similarity(a, b):
|
||||
"""Calculate cosine similarity between two vectors."""
|
||||
dot_product = sum(x * y for x, y in zip(a, b))
|
||||
norm_a = sum(x * x for x in a) ** 0.5
|
||||
norm_b = sum(x * x for x in b) ** 0.5
|
||||
return dot_product / (norm_a * norm_b) if norm_a and norm_b else 0
|
||||
|
||||
# Generate embedding for a similar query
|
||||
query = "OAuth authentication implementation"
|
||||
resp = requests.post(
|
||||
f"{ollama_base_url}/api/embeddings",
|
||||
json={"model": ollama_model, "prompt": query},
|
||||
timeout=60,
|
||||
)
|
||||
query_embedding = resp.json().get("embedding", [])
|
||||
|
||||
similarities = [cosine_similarity(query_embedding, emb) for emb in embeddings]
|
||||
|
||||
print(f" Query: '{query}'")
|
||||
print(" Similarities to test texts:")
|
||||
for i, (text, sim) in enumerate(zip(test_texts, similarities)):
|
||||
print(f" {i + 1}. {sim:.4f} - '{text[:50]}...'")
|
||||
|
||||
# First text (about OAuth) should have highest similarity to OAuth query
|
||||
if similarities[0] > similarities[1] and similarities[0] > similarities[2]:
|
||||
print_result("Semantic similarity", "OAuth query matches OAuth text best", True)
|
||||
else:
|
||||
print_info("Similarity ordering may vary - embeddings are still working")
|
||||
|
||||
print()
|
||||
print_result("Ollama Embeddings", "All tests passed", True)
|
||||
return True
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# Test 2: Memory Creation with Ollama
|
||||
# ============================================================================
|
||||
|
||||
|
||||
async def test_memory_creation(test_db_path: Path) -> tuple[Path, Path, bool]:
|
||||
"""
|
||||
Test creating memories using GraphitiMemory with Ollama embeddings.
|
||||
|
||||
Returns:
|
||||
Tuple of (spec_dir, project_dir, success)
|
||||
"""
|
||||
print_header("Test 2: Memory Creation with Ollama Embeddings")
|
||||
|
||||
# Create test directories
|
||||
spec_dir = test_db_path / "test_spec"
|
||||
project_dir = test_db_path / "test_project"
|
||||
spec_dir.mkdir(parents=True, exist_ok=True)
|
||||
project_dir.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
print(f" Spec dir: {spec_dir}")
|
||||
print(f" Project dir: {project_dir}")
|
||||
print(f" Database path: {test_db_path}")
|
||||
print()
|
||||
|
||||
# Override database path for testing
|
||||
os.environ["GRAPHITI_DB_PATH"] = str(test_db_path / "graphiti_db")
|
||||
os.environ["GRAPHITI_DATABASE"] = "test_ollama_memory"
|
||||
|
||||
try:
|
||||
from integrations.graphiti.memory import GraphitiMemory
|
||||
except ImportError as e:
|
||||
print_result("Import GraphitiMemory", f"Failed: {e}", False)
|
||||
return spec_dir, project_dir, False
|
||||
|
||||
# Step 1: Initialize GraphitiMemory
|
||||
print_step(1, "Initializing GraphitiMemory")
|
||||
|
||||
memory = GraphitiMemory(spec_dir, project_dir)
|
||||
print(f" Is enabled: {memory.is_enabled}")
|
||||
print(f" Group ID: {memory.group_id}")
|
||||
|
||||
if not memory.is_enabled:
|
||||
print_result(
|
||||
"GraphitiMemory",
|
||||
"Not enabled - check GRAPHITI_ENABLED=true",
|
||||
False,
|
||||
)
|
||||
return spec_dir, project_dir, False
|
||||
|
||||
init_result = await memory.initialize()
|
||||
if not init_result:
|
||||
print_result("Initialize", "Failed to initialize", False)
|
||||
return spec_dir, project_dir, False
|
||||
|
||||
print_result("Initialize", "SUCCESS", True)
|
||||
|
||||
# Step 2: Save session insights
|
||||
print_step(2, "Saving session insights")
|
||||
|
||||
session_insights = {
|
||||
"subtasks_completed": ["implement-oauth-login", "add-jwt-validation"],
|
||||
"discoveries": {
|
||||
"files_understood": {
|
||||
"auth/oauth.py": "OAuth 2.0 flow implementation with Google/GitHub",
|
||||
"auth/jwt.py": "JWT token generation and validation utilities",
|
||||
},
|
||||
"patterns_found": [
|
||||
"Pattern: Use refresh tokens for long-lived sessions",
|
||||
"Pattern: Store tokens in httpOnly cookies for security",
|
||||
],
|
||||
"gotchas_encountered": [
|
||||
"Gotcha: Always validate JWT signature on server side",
|
||||
"Gotcha: OAuth state parameter prevents CSRF attacks",
|
||||
],
|
||||
},
|
||||
"what_worked": [
|
||||
"Using PyJWT for token handling",
|
||||
"Separating OAuth providers into individual modules",
|
||||
],
|
||||
"what_failed": [],
|
||||
"recommendations_for_next_session": [
|
||||
"Consider adding refresh token rotation",
|
||||
"Add rate limiting to auth endpoints",
|
||||
],
|
||||
}
|
||||
|
||||
save_result = await memory.save_session_insights(
|
||||
session_num=1, insights=session_insights
|
||||
)
|
||||
print_result(
|
||||
"save_session_insights", "SUCCESS" if save_result else "FAILED", save_result
|
||||
)
|
||||
|
||||
# Step 3: Save patterns
|
||||
print_step(3, "Saving code patterns")
|
||||
|
||||
patterns = [
|
||||
"OAuth implementation uses authorization code flow for web apps",
|
||||
"JWT tokens include user ID, roles, and expiration in payload",
|
||||
"Token refresh happens automatically when access token expires",
|
||||
]
|
||||
|
||||
for i, pattern in enumerate(patterns):
|
||||
result = await memory.save_pattern(pattern)
|
||||
print_result(f"save_pattern {i + 1}", "SUCCESS" if result else "FAILED", result)
|
||||
|
||||
# Step 4: Save gotchas
|
||||
print_step(4, "Saving gotchas (pitfalls)")
|
||||
|
||||
gotchas = [
|
||||
"Never store config values in frontend code or files checked into git",
|
||||
"API redirect URIs must exactly match the registered URIs",
|
||||
"Cache expiration times should be short for performance (15 min default)",
|
||||
]
|
||||
|
||||
for i, gotcha in enumerate(gotchas):
|
||||
result = await memory.save_gotcha(gotcha)
|
||||
print_result(f"save_gotcha {i + 1}", "SUCCESS" if result else "FAILED", result)
|
||||
|
||||
# Step 5: Save codebase discoveries
|
||||
print_step(5, "Saving codebase discoveries")
|
||||
|
||||
discoveries = {
|
||||
"api/routes/users.py": "User management API endpoints (list, create, update)",
|
||||
"middleware/logging.py": "Request logging middleware for all routes",
|
||||
"models/user.py": "User model with profile data and role management",
|
||||
"services/notifications.py": "Notification service integrations (email, SMS, push)",
|
||||
}
|
||||
|
||||
discovery_result = await memory.save_codebase_discoveries(discoveries)
|
||||
print_result(
|
||||
"save_codebase_discoveries",
|
||||
"SUCCESS" if discovery_result else "FAILED",
|
||||
discovery_result,
|
||||
)
|
||||
|
||||
# Brief wait for embedding processing
|
||||
print()
|
||||
print_info("Waiting 3 seconds for embedding processing...")
|
||||
await asyncio.sleep(3)
|
||||
|
||||
await memory.close()
|
||||
|
||||
print()
|
||||
print_result("Memory Creation", "All memories saved successfully", True)
|
||||
return spec_dir, project_dir, True
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# Test 3: Memory Retrieval with Semantic Search
|
||||
# ============================================================================
|
||||
|
||||
|
||||
async def test_memory_retrieval(spec_dir: Path, project_dir: Path) -> bool:
|
||||
"""
|
||||
Test retrieving memories using semantic search with Ollama embeddings.
|
||||
|
||||
This validates that saved memories can be found via semantic similarity.
|
||||
"""
|
||||
print_header("Test 3: Memory Retrieval with Semantic Search")
|
||||
|
||||
try:
|
||||
from integrations.graphiti.memory import GraphitiMemory
|
||||
except ImportError as e:
|
||||
print_result("Import GraphitiMemory", f"Failed: {e}", False)
|
||||
return False
|
||||
|
||||
# Step 1: Initialize memory (reconnect)
|
||||
print_step(1, "Reconnecting to GraphitiMemory")
|
||||
|
||||
memory = GraphitiMemory(spec_dir, project_dir)
|
||||
init_result = await memory.initialize()
|
||||
|
||||
if not init_result:
|
||||
print_result("Initialize", "Failed to reconnect", False)
|
||||
return False
|
||||
|
||||
print_result("Initialize", "Reconnected successfully", True)
|
||||
|
||||
# Step 2: Semantic search for API-related content
|
||||
print_step(2, "Searching for API-related memories")
|
||||
|
||||
api_query = "How do the API endpoints work in this project?"
|
||||
results = await memory.get_relevant_context(api_query, num_results=5)
|
||||
|
||||
print(f" Query: '{api_query}'")
|
||||
print(f" Found {len(results)} results:")
|
||||
|
||||
api_found = False
|
||||
for i, result in enumerate(results):
|
||||
content = result.get("content", "")[:100]
|
||||
result_type = result.get("type", "unknown")
|
||||
score = result.get("score", 0)
|
||||
print(f" {i + 1}. [{result_type}] (score: {score:.4f}) {content}...")
|
||||
if "api" in content.lower() or "routes" in content.lower():
|
||||
api_found = True
|
||||
|
||||
if api_found:
|
||||
print_result("API search", "Found API-related content", True)
|
||||
else:
|
||||
print_info("API content may not be in top results - checking other queries")
|
||||
|
||||
# Step 3: Search for middleware-related content
|
||||
print_step(3, "Searching for middleware patterns")
|
||||
|
||||
middleware_query = "middleware and request handling best practices"
|
||||
results = await memory.get_relevant_context(middleware_query, num_results=5)
|
||||
|
||||
print(f" Query: '{middleware_query}'")
|
||||
print(f" Found {len(results)} results:")
|
||||
|
||||
middleware_found = False
|
||||
for i, result in enumerate(results):
|
||||
content = result.get("content", "")[:100]
|
||||
result_type = result.get("type", "unknown")
|
||||
score = result.get("score", 0)
|
||||
print(f" {i + 1}. [{result_type}] (score: {score:.4f}) {content}...")
|
||||
if "middleware" in content.lower() or "routes" in content.lower():
|
||||
middleware_found = True
|
||||
|
||||
print_result(
|
||||
"Middleware search",
|
||||
"Found middleware-related content" if middleware_found else "No direct matches",
|
||||
middleware_found or len(results) > 0,
|
||||
)
|
||||
|
||||
# Step 4: Get session history
|
||||
print_step(4, "Retrieving session history")
|
||||
|
||||
history = await memory.get_session_history(limit=3)
|
||||
print(f" Found {len(history)} session records:")
|
||||
|
||||
for i, session in enumerate(history):
|
||||
session_num = session.get("session_number", "?")
|
||||
subtasks = session.get("subtasks_completed", [])
|
||||
print(f" Session {session_num}: {len(subtasks)} subtasks completed")
|
||||
for subtask in subtasks[:3]:
|
||||
print(f" - {subtask}")
|
||||
|
||||
print_result(
|
||||
"Session history", f"Retrieved {len(history)} sessions", len(history) > 0
|
||||
)
|
||||
|
||||
# Step 5: Get status summary
|
||||
print_step(5, "Memory status summary")
|
||||
|
||||
status = memory.get_status_summary()
|
||||
for key, value in status.items():
|
||||
print(f" {key}: {value}")
|
||||
|
||||
await memory.close()
|
||||
|
||||
print()
|
||||
all_passed = len(results) > 0 and len(history) > 0
|
||||
print_result(
|
||||
"Memory Retrieval",
|
||||
"All retrieval tests passed" if all_passed else "Some tests had issues",
|
||||
all_passed,
|
||||
)
|
||||
return all_passed
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# Test 4: Full Create → Store → Retrieve Cycle
|
||||
# ============================================================================
|
||||
|
||||
|
||||
async def test_full_cycle(test_db_path: Path) -> bool:
|
||||
"""
|
||||
Test the complete memory lifecycle:
|
||||
1. Create unique test data
|
||||
2. Store in graph database with Ollama embeddings
|
||||
3. Search and retrieve via semantic similarity
|
||||
4. Verify retrieved data matches what was stored
|
||||
"""
|
||||
print_header("Test 4: Full Create-Store-Retrieve Cycle")
|
||||
|
||||
# Create fresh test directories
|
||||
spec_dir = test_db_path / "cycle_test_spec"
|
||||
project_dir = test_db_path / "cycle_test_project"
|
||||
spec_dir.mkdir(parents=True, exist_ok=True)
|
||||
project_dir.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
# Override database path for testing
|
||||
os.environ["GRAPHITI_DB_PATH"] = str(test_db_path / "graphiti_db")
|
||||
os.environ["GRAPHITI_DATABASE"] = "test_full_cycle"
|
||||
|
||||
try:
|
||||
from integrations.graphiti.memory import GraphitiMemory
|
||||
except ImportError as e:
|
||||
print_result("Import", f"Failed: {e}", False)
|
||||
return False
|
||||
|
||||
# Step 1: Create unique test content
|
||||
print_step(1, "Creating unique test content")
|
||||
|
||||
unique_id = datetime.now().strftime("%Y%m%d_%H%M%S")
|
||||
unique_pattern = (
|
||||
f"Unique pattern {unique_id}: Use dependency injection for database connections"
|
||||
)
|
||||
unique_gotcha = f"Unique gotcha {unique_id}: Always close database connections in finally blocks"
|
||||
|
||||
print(f" Unique ID: {unique_id}")
|
||||
print(f" Pattern: {unique_pattern[:60]}...")
|
||||
print(f" Gotcha: {unique_gotcha[:60]}...")
|
||||
|
||||
# Step 2: Store the content
|
||||
print_step(2, "Storing content in memory system")
|
||||
|
||||
memory = GraphitiMemory(spec_dir, project_dir)
|
||||
init_result = await memory.initialize()
|
||||
|
||||
if not init_result:
|
||||
print_result("Initialize", "Failed", False)
|
||||
return False
|
||||
|
||||
print_result("Initialize", "SUCCESS", True)
|
||||
|
||||
pattern_result = await memory.save_pattern(unique_pattern)
|
||||
print_result(
|
||||
"save_pattern", "SUCCESS" if pattern_result else "FAILED", pattern_result
|
||||
)
|
||||
|
||||
gotcha_result = await memory.save_gotcha(unique_gotcha)
|
||||
print_result("save_gotcha", "SUCCESS" if gotcha_result else "FAILED", gotcha_result)
|
||||
|
||||
# Wait for embedding processing
|
||||
print()
|
||||
print_info("Waiting 4 seconds for embedding processing and indexing...")
|
||||
await asyncio.sleep(4)
|
||||
|
||||
# Step 3: Search for the unique content
|
||||
print_step(3, "Searching for unique content")
|
||||
|
||||
# Search for the pattern
|
||||
pattern_query = "dependency injection database connections"
|
||||
pattern_results = await memory.get_relevant_context(pattern_query, num_results=5)
|
||||
|
||||
print(f" Query: '{pattern_query}'")
|
||||
print(f" Found {len(pattern_results)} results")
|
||||
|
||||
pattern_found = False
|
||||
for result in pattern_results:
|
||||
content = result.get("content", "")
|
||||
if unique_id in content:
|
||||
pattern_found = True
|
||||
print(f" MATCH: {content[:80]}...")
|
||||
|
||||
print_result(
|
||||
"Pattern retrieval",
|
||||
f"Found unique pattern (ID: {unique_id})"
|
||||
if pattern_found
|
||||
else "Unique pattern not in top results",
|
||||
pattern_found,
|
||||
)
|
||||
|
||||
# Search for the gotcha
|
||||
gotcha_query = "database connection cleanup finally block"
|
||||
gotcha_results = await memory.get_relevant_context(gotcha_query, num_results=5)
|
||||
|
||||
print(f" Query: '{gotcha_query}'")
|
||||
print(f" Found {len(gotcha_results)} results")
|
||||
|
||||
gotcha_found = False
|
||||
for result in gotcha_results:
|
||||
content = result.get("content", "")
|
||||
if unique_id in content:
|
||||
gotcha_found = True
|
||||
print(f" MATCH: {content[:80]}...")
|
||||
|
||||
print_result(
|
||||
"Gotcha retrieval",
|
||||
f"Found unique gotcha (ID: {unique_id})"
|
||||
if gotcha_found
|
||||
else "Unique gotcha not in top results",
|
||||
gotcha_found,
|
||||
)
|
||||
|
||||
# Step 4: Verify semantic similarity works
|
||||
print_step(4, "Verifying semantic similarity")
|
||||
|
||||
# Search with semantically similar but different wording
|
||||
alt_query = "closing connections properly in error handling"
|
||||
alt_results = await memory.get_relevant_context(alt_query, num_results=3)
|
||||
|
||||
print(f" Alternative query: '{alt_query}'")
|
||||
print(f" Found {len(alt_results)} semantically similar results:")
|
||||
|
||||
for i, result in enumerate(alt_results):
|
||||
content = result.get("content", "")[:80]
|
||||
score = result.get("score", 0)
|
||||
print(f" {i + 1}. (score: {score:.4f}) {content}...")
|
||||
|
||||
semantic_works = len(alt_results) > 0
|
||||
print_result(
|
||||
"Semantic similarity",
|
||||
"Working - found related content" if semantic_works else "No results",
|
||||
semantic_works,
|
||||
)
|
||||
|
||||
await memory.close()
|
||||
|
||||
# Summary
|
||||
print()
|
||||
cycle_passed = (
|
||||
pattern_result
|
||||
and gotcha_result
|
||||
and (pattern_found or gotcha_found or len(alt_results) > 0)
|
||||
)
|
||||
print_result(
|
||||
"Full Cycle Test",
|
||||
"Create-Store-Retrieve cycle verified"
|
||||
if cycle_passed
|
||||
else "Some steps had issues",
|
||||
cycle_passed,
|
||||
)
|
||||
|
||||
return cycle_passed
|
||||
|
||||
|
||||
# ============================================================================
|
||||
# Main Entry Point
|
||||
# ============================================================================
|
||||
|
||||
|
||||
async def main():
|
||||
"""Run Ollama embedding memory tests."""
|
||||
parser = argparse.ArgumentParser(
|
||||
description="Test Ollama Embedding Memory Integration"
|
||||
)
|
||||
parser.add_argument(
|
||||
"--test",
|
||||
choices=["all", "embeddings", "create", "retrieve", "full-cycle"],
|
||||
default="all",
|
||||
help="Which test to run",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--keep-db",
|
||||
action="store_true",
|
||||
help="Keep test database after completion (default: cleanup)",
|
||||
)
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
print("\n" + "=" * 70)
|
||||
print(" OLLAMA EMBEDDING MEMORY TEST SUITE")
|
||||
print("=" * 70)
|
||||
|
||||
# Configuration check
|
||||
print_header("Configuration Check")
|
||||
|
||||
config_items = {
|
||||
"GRAPHITI_ENABLED": os.environ.get("GRAPHITI_ENABLED", ""),
|
||||
"GRAPHITI_LLM_PROVIDER": os.environ.get("GRAPHITI_LLM_PROVIDER", ""),
|
||||
"GRAPHITI_EMBEDDER_PROVIDER": os.environ.get("GRAPHITI_EMBEDDER_PROVIDER", ""),
|
||||
"OLLAMA_LLM_MODEL": os.environ.get("OLLAMA_LLM_MODEL", ""),
|
||||
"OLLAMA_EMBEDDING_MODEL": os.environ.get("OLLAMA_EMBEDDING_MODEL", ""),
|
||||
"OLLAMA_EMBEDDING_DIM": os.environ.get("OLLAMA_EMBEDDING_DIM", ""),
|
||||
"OLLAMA_BASE_URL": os.environ.get("OLLAMA_BASE_URL", "http://localhost:11434"),
|
||||
"OPENAI_API_KEY": "(set)"
|
||||
if os.environ.get("OPENAI_API_KEY")
|
||||
else "(not set - needed for reranker)",
|
||||
}
|
||||
|
||||
all_configured = True
|
||||
required_keys = [
|
||||
"GRAPHITI_ENABLED",
|
||||
"GRAPHITI_LLM_PROVIDER",
|
||||
"GRAPHITI_EMBEDDER_PROVIDER",
|
||||
"OLLAMA_LLM_MODEL",
|
||||
"OLLAMA_EMBEDDING_MODEL",
|
||||
]
|
||||
|
||||
for key, value in config_items.items():
|
||||
is_optional = key in [
|
||||
"OLLAMA_BASE_URL",
|
||||
"OPENAI_API_KEY",
|
||||
"OLLAMA_EMBEDDING_DIM",
|
||||
]
|
||||
is_set = bool(value) if not is_optional else True
|
||||
display_value = value or "(not set)"
|
||||
if key == "OPENAI_API_KEY":
|
||||
display_value = value # Already formatted above
|
||||
is_set = True # Optional for testing
|
||||
print_result(key, display_value, is_set)
|
||||
if key in required_keys and not bool(os.environ.get(key)):
|
||||
all_configured = False
|
||||
|
||||
if not all_configured:
|
||||
print()
|
||||
print(" Missing required configuration. Please set:")
|
||||
print(" export GRAPHITI_ENABLED=true")
|
||||
print(" export GRAPHITI_LLM_PROVIDER=ollama")
|
||||
print(" export GRAPHITI_EMBEDDER_PROVIDER=ollama")
|
||||
print(" export OLLAMA_LLM_MODEL=deepseek-r1:7b")
|
||||
print(" export OLLAMA_EMBEDDING_MODEL=embeddinggemma")
|
||||
print(" export OLLAMA_EMBEDDING_DIM=768")
|
||||
print(" export OPENAI_API_KEY=dummy # For graphiti-core reranker")
|
||||
print()
|
||||
return
|
||||
|
||||
# Check LadybugDB
|
||||
if not apply_ladybug_monkeypatch():
|
||||
print()
|
||||
print_result("LadybugDB", "Not installed - pip install real-ladybug", False)
|
||||
return
|
||||
|
||||
print_result("LadybugDB", "Installed", True)
|
||||
|
||||
# Create temp directory for test database
|
||||
test_db_path = Path(tempfile.mkdtemp(prefix="ollama_memory_test_"))
|
||||
print()
|
||||
print_info(f"Test database: {test_db_path}")
|
||||
|
||||
# Run tests
|
||||
test = args.test
|
||||
results = {}
|
||||
|
||||
try:
|
||||
if test in ["all", "embeddings"]:
|
||||
results["embeddings"] = await test_ollama_embeddings()
|
||||
|
||||
spec_dir = None
|
||||
project_dir = None
|
||||
|
||||
if test in ["all", "create"]:
|
||||
spec_dir, project_dir, results["create"] = await test_memory_creation(
|
||||
test_db_path
|
||||
)
|
||||
|
||||
if test in ["all", "retrieve"]:
|
||||
if spec_dir and project_dir:
|
||||
results["retrieve"] = await test_memory_retrieval(spec_dir, project_dir)
|
||||
else:
|
||||
print_info(
|
||||
"Skipping retrieve test - no spec/project dir from create test"
|
||||
)
|
||||
|
||||
if test in ["all", "full-cycle"]:
|
||||
results["full-cycle"] = await test_full_cycle(test_db_path)
|
||||
|
||||
finally:
|
||||
# Cleanup unless --keep-db specified
|
||||
if not args.keep_db and test_db_path.exists():
|
||||
print()
|
||||
print_info(f"Cleaning up test database: {test_db_path}")
|
||||
shutil.rmtree(test_db_path, ignore_errors=True)
|
||||
|
||||
# Summary
|
||||
print_header("TEST SUMMARY")
|
||||
|
||||
all_passed = True
|
||||
for test_name, passed in results.items():
|
||||
status = "PASSED" if passed else "FAILED"
|
||||
print(f" {test_name}: {status}")
|
||||
if not passed:
|
||||
all_passed = False
|
||||
|
||||
print()
|
||||
if all_passed:
|
||||
print(" All tests PASSED!")
|
||||
print()
|
||||
print(" The memory system is working correctly with Ollama embeddings.")
|
||||
print(" Memories can be created and retrieved using semantic search.")
|
||||
else:
|
||||
print(" Some tests FAILED. Check the output above for details.")
|
||||
print()
|
||||
print(" Common issues:")
|
||||
print(" - Ollama not running: ollama serve")
|
||||
print(" - Model not pulled: ollama pull embeddinggemma")
|
||||
print(" - Wrong dimension: Update OLLAMA_EMBEDDING_DIM to match model")
|
||||
|
||||
print()
|
||||
print(" Commands:")
|
||||
print(" # Run all tests:")
|
||||
print(" python integrations/graphiti/test_ollama_embedding_memory.py")
|
||||
print()
|
||||
print(" # Run specific test:")
|
||||
print(
|
||||
" python integrations/graphiti/test_ollama_embedding_memory.py --test embeddings"
|
||||
)
|
||||
print(
|
||||
" python integrations/graphiti/test_ollama_embedding_memory.py --test full-cycle"
|
||||
)
|
||||
print()
|
||||
print(" # Keep database for inspection:")
|
||||
print(" python integrations/graphiti/test_ollama_embedding_memory.py --keep-db")
|
||||
print()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
asyncio.run(main())
|
||||
@@ -43,9 +43,9 @@ def create_claude_resolver() -> AIResolver:
|
||||
ensure_claude_code_oauth_token()
|
||||
|
||||
try:
|
||||
from core.simple_client import create_simple_client
|
||||
from claude_agent_sdk import ClaudeAgentOptions, ClaudeSDKClient
|
||||
except ImportError:
|
||||
logger.warning("core.simple_client not available, AI resolution unavailable")
|
||||
logger.warning("claude_agent_sdk not installed, AI resolution unavailable")
|
||||
return AIResolver()
|
||||
|
||||
def call_claude(system: str, user: str) -> str:
|
||||
@@ -53,10 +53,13 @@ def create_claude_resolver() -> AIResolver:
|
||||
|
||||
async def _run_merge() -> str:
|
||||
# Create a minimal client for merge resolution
|
||||
client = create_simple_client(
|
||||
agent_type="merge_resolver",
|
||||
model="sonnet",
|
||||
system_prompt=system,
|
||||
client = ClaudeSDKClient(
|
||||
options=ClaudeAgentOptions(
|
||||
model="sonnet",
|
||||
system_prompt=system,
|
||||
allowed_tools=[], # No tools needed for merge
|
||||
max_turns=1,
|
||||
)
|
||||
)
|
||||
|
||||
try:
|
||||
|
||||
@@ -180,8 +180,8 @@ class EvolutionStorage:
|
||||
try:
|
||||
# Resolve both paths to handle symlinks (e.g., /var -> /private/var on macOS)
|
||||
resolved_path = path.resolve()
|
||||
return resolved_path.relative_to(self.project_dir).as_posix()
|
||||
return str(resolved_path.relative_to(self.project_dir))
|
||||
except ValueError:
|
||||
# Path is not under project_dir, return as-is
|
||||
return path.as_posix()
|
||||
return path.as_posix()
|
||||
return str(path)
|
||||
return str(path)
|
||||
|
||||
@@ -57,33 +57,18 @@ KNOWN_EMBEDDING_MODELS = {
|
||||
|
||||
# Recommended embedding models for download (shown in UI)
|
||||
RECOMMENDED_EMBEDDING_MODELS = [
|
||||
{
|
||||
"name": "qwen3-embedding:4b",
|
||||
"description": "Qwen3 4B - Balanced quality and speed",
|
||||
"size_estimate": "3.1 GB",
|
||||
"dim": 2560,
|
||||
"badge": "recommended",
|
||||
},
|
||||
{
|
||||
"name": "qwen3-embedding:8b",
|
||||
"description": "Qwen3 8B - Best embedding quality",
|
||||
"size_estimate": "6.0 GB",
|
||||
"dim": 4096,
|
||||
"badge": "quality",
|
||||
},
|
||||
{
|
||||
"name": "qwen3-embedding:0.6b",
|
||||
"description": "Qwen3 0.6B - Smallest and fastest",
|
||||
"size_estimate": "494 MB",
|
||||
"dim": 1024,
|
||||
"badge": "fast",
|
||||
},
|
||||
{
|
||||
"name": "embeddinggemma",
|
||||
"description": "Google's lightweight embedding model (768 dim)",
|
||||
"size_estimate": "621 MB",
|
||||
"dim": 768,
|
||||
},
|
||||
{
|
||||
"name": "qwen3-embedding:0.6b",
|
||||
"description": "Qwen3 small embedding model (1024 dim)",
|
||||
"size_estimate": "494 MB",
|
||||
"dim": 1024,
|
||||
},
|
||||
{
|
||||
"name": "nomic-embed-text",
|
||||
"description": "Popular general-purpose embeddings (768 dim)",
|
||||
@@ -355,59 +340,50 @@ def cmd_get_recommended_models(args) -> None:
|
||||
|
||||
|
||||
def cmd_pull_model(args) -> None:
|
||||
"""Pull (download) an Ollama model using the HTTP API for progress tracking."""
|
||||
model_name = args.model
|
||||
base_url = getattr(args, "base_url", None) or DEFAULT_OLLAMA_URL
|
||||
"""Pull (download) an Ollama model."""
|
||||
import subprocess
|
||||
|
||||
model_name = args.model
|
||||
if not model_name:
|
||||
output_error("Model name is required")
|
||||
return
|
||||
|
||||
try:
|
||||
url = f"{base_url.rstrip('/')}/api/pull"
|
||||
data = json.dumps({"name": model_name}).encode("utf-8")
|
||||
|
||||
req = urllib.request.Request(url, data=data, method="POST")
|
||||
req.add_header("Content-Type", "application/json")
|
||||
|
||||
with urllib.request.urlopen(req, timeout=600) as response:
|
||||
# Ollama streams NDJSON (newline-delimited JSON) progress
|
||||
for line in response:
|
||||
try:
|
||||
progress = json.loads(line.decode("utf-8"))
|
||||
|
||||
# Emit progress as NDJSON to stderr for main process to parse
|
||||
if "completed" in progress and "total" in progress:
|
||||
print(
|
||||
json.dumps(
|
||||
{
|
||||
"status": progress.get("status", "downloading"),
|
||||
"completed": progress.get("completed", 0),
|
||||
"total": progress.get("total", 0),
|
||||
}
|
||||
),
|
||||
file=sys.stderr,
|
||||
flush=True,
|
||||
)
|
||||
elif progress.get("status") == "success":
|
||||
# Download complete
|
||||
pass
|
||||
except json.JSONDecodeError:
|
||||
continue
|
||||
|
||||
output_json(
|
||||
True,
|
||||
data={
|
||||
"model": model_name,
|
||||
"status": "completed",
|
||||
"output": ["Download completed successfully"],
|
||||
},
|
||||
# Run ollama pull command
|
||||
process = subprocess.Popen(
|
||||
["ollama", "pull", model_name],
|
||||
stdout=subprocess.PIPE,
|
||||
stderr=subprocess.STDOUT,
|
||||
text=True,
|
||||
bufsize=1,
|
||||
)
|
||||
|
||||
except urllib.error.URLError as e:
|
||||
output_error(f"Failed to connect to Ollama: {str(e)}")
|
||||
except urllib.error.HTTPError as e:
|
||||
output_error(f"Ollama API error: {e.code} - {e.reason}")
|
||||
output_lines = []
|
||||
for line in iter(process.stdout.readline, ""):
|
||||
line = line.strip()
|
||||
if line:
|
||||
output_lines.append(line)
|
||||
# Print progress to stderr for streaming
|
||||
print(line, file=sys.stderr, flush=True)
|
||||
|
||||
process.wait()
|
||||
|
||||
if process.returncode == 0:
|
||||
output_json(
|
||||
True,
|
||||
data={
|
||||
"model": model_name,
|
||||
"status": "completed",
|
||||
"output": output_lines,
|
||||
},
|
||||
)
|
||||
else:
|
||||
output_json(
|
||||
False, error=f"Failed to pull model: {' '.join(output_lines[-3:])}"
|
||||
)
|
||||
|
||||
except FileNotFoundError:
|
||||
output_error("Ollama CLI not found. Please install Ollama first.")
|
||||
except Exception as e:
|
||||
output_error(f"Failed to pull model: {str(e)}")
|
||||
|
||||
|
||||
@@ -1,16 +0,0 @@
|
||||
"""
|
||||
Phase event facade for frontend synchronization.
|
||||
Re-exports from core.phase_event for clean imports.
|
||||
"""
|
||||
|
||||
from core.phase_event import (
|
||||
PHASE_MARKER_PREFIX,
|
||||
ExecutionPhase,
|
||||
emit_phase,
|
||||
)
|
||||
|
||||
__all__ = [
|
||||
"PHASE_MARKER_PREFIX",
|
||||
"ExecutionPhase",
|
||||
"emit_phase",
|
||||
]
|
||||
@@ -11,26 +11,6 @@ from implementation_plan import WorkflowType
|
||||
from .models import PlannerContext
|
||||
|
||||
|
||||
def _normalize_workflow_type(value: str) -> str:
|
||||
"""Normalize workflow type strings for consistent mapping.
|
||||
|
||||
Strips whitespace, lowercases the value and removes underscores so variants
|
||||
like 'bug_fix' or 'BugFix' map to the same key.
|
||||
"""
|
||||
normalized = (value or "").strip().lower()
|
||||
return normalized.replace("_", "")
|
||||
|
||||
|
||||
_WORKFLOW_TYPE_MAPPING: dict[str, WorkflowType] = {
|
||||
"feature": WorkflowType.FEATURE,
|
||||
"refactor": WorkflowType.REFACTOR,
|
||||
"investigation": WorkflowType.INVESTIGATION,
|
||||
"migration": WorkflowType.MIGRATION,
|
||||
"simple": WorkflowType.SIMPLE,
|
||||
"bugfix": WorkflowType.INVESTIGATION,
|
||||
}
|
||||
|
||||
|
||||
class ContextLoader:
|
||||
"""Loads context files and determines workflow type."""
|
||||
|
||||
@@ -84,6 +64,13 @@ class ContextLoader:
|
||||
3. spec.md explicit declaration - Spec writer's declaration
|
||||
4. Keyword-based detection - Last resort fallback
|
||||
"""
|
||||
type_mapping = {
|
||||
"feature": WorkflowType.FEATURE,
|
||||
"refactor": WorkflowType.REFACTOR,
|
||||
"investigation": WorkflowType.INVESTIGATION,
|
||||
"migration": WorkflowType.MIGRATION,
|
||||
"simple": WorkflowType.SIMPLE,
|
||||
}
|
||||
|
||||
# 1. Check requirements.json (user's explicit intent)
|
||||
requirements_file = self.spec_dir / "requirements.json"
|
||||
@@ -91,11 +78,9 @@ class ContextLoader:
|
||||
try:
|
||||
with open(requirements_file) as f:
|
||||
requirements = json.load(f)
|
||||
declared_type = _normalize_workflow_type(
|
||||
requirements.get("workflow_type", "")
|
||||
)
|
||||
if declared_type in _WORKFLOW_TYPE_MAPPING:
|
||||
return _WORKFLOW_TYPE_MAPPING[declared_type]
|
||||
declared_type = requirements.get("workflow_type", "").lower()
|
||||
if declared_type in type_mapping:
|
||||
return type_mapping[declared_type]
|
||||
except (json.JSONDecodeError, KeyError):
|
||||
pass
|
||||
|
||||
@@ -105,11 +90,9 @@ class ContextLoader:
|
||||
try:
|
||||
with open(assessment_file) as f:
|
||||
assessment = json.load(f)
|
||||
declared_type = _normalize_workflow_type(
|
||||
assessment.get("workflow_type", "")
|
||||
)
|
||||
if declared_type in _WORKFLOW_TYPE_MAPPING:
|
||||
return _WORKFLOW_TYPE_MAPPING[declared_type]
|
||||
declared_type = assessment.get("workflow_type", "").lower()
|
||||
if declared_type in type_mapping:
|
||||
return type_mapping[declared_type]
|
||||
except (json.JSONDecodeError, KeyError):
|
||||
pass
|
||||
|
||||
@@ -125,6 +108,14 @@ class ContextLoader:
|
||||
"""
|
||||
content_lower = spec_content.lower()
|
||||
|
||||
type_mapping = {
|
||||
"feature": WorkflowType.FEATURE,
|
||||
"refactor": WorkflowType.REFACTOR,
|
||||
"investigation": WorkflowType.INVESTIGATION,
|
||||
"migration": WorkflowType.MIGRATION,
|
||||
"simple": WorkflowType.SIMPLE,
|
||||
}
|
||||
|
||||
# Check for explicit workflow type declaration in spec
|
||||
# Look for patterns like "**Type**: feature" or "Type: refactor"
|
||||
explicit_type_patterns = [
|
||||
@@ -136,9 +127,9 @@ class ContextLoader:
|
||||
for pattern in explicit_type_patterns:
|
||||
match = re.search(pattern, content_lower)
|
||||
if match:
|
||||
declared_type = _normalize_workflow_type(match.group(1))
|
||||
if declared_type in _WORKFLOW_TYPE_MAPPING:
|
||||
return _WORKFLOW_TYPE_MAPPING[declared_type]
|
||||
declared_type = match.group(1).strip()
|
||||
if declared_type in type_mapping:
|
||||
return type_mapping[declared_type]
|
||||
|
||||
# FALLBACK: Keyword-based detection (only if no explicit type found)
|
||||
# Investigation indicators
|
||||
|
||||
@@ -90,56 +90,29 @@ class ProjectAnalyzer:
|
||||
This allows us to know when to re-analyze.
|
||||
"""
|
||||
hash_files = [
|
||||
# JavaScript/TypeScript
|
||||
"package.json",
|
||||
"package-lock.json",
|
||||
"yarn.lock",
|
||||
"pnpm-lock.yaml",
|
||||
# Python
|
||||
"pyproject.toml",
|
||||
"requirements.txt",
|
||||
"Pipfile",
|
||||
"poetry.lock",
|
||||
# Rust
|
||||
"Cargo.toml",
|
||||
"Cargo.lock",
|
||||
# Go
|
||||
"go.mod",
|
||||
"go.sum",
|
||||
# Ruby
|
||||
"Gemfile",
|
||||
"Gemfile.lock",
|
||||
# PHP
|
||||
"composer.json",
|
||||
"composer.lock",
|
||||
# Dart/Flutter
|
||||
"pubspec.yaml",
|
||||
"pubspec.lock",
|
||||
# Java/Kotlin/Scala
|
||||
"pom.xml",
|
||||
"build.gradle",
|
||||
"build.gradle.kts",
|
||||
"settings.gradle",
|
||||
"settings.gradle.kts",
|
||||
"build.sbt",
|
||||
# Swift
|
||||
"Package.swift",
|
||||
# Infrastructure
|
||||
"Makefile",
|
||||
"Dockerfile",
|
||||
"docker-compose.yml",
|
||||
"docker-compose.yaml",
|
||||
]
|
||||
|
||||
# Glob patterns for project files that can be anywhere in the tree
|
||||
glob_patterns = [
|
||||
"*.csproj", # C# projects
|
||||
"*.sln", # Visual Studio solutions
|
||||
"*.fsproj", # F# projects
|
||||
"*.vbproj", # VB.NET projects
|
||||
]
|
||||
|
||||
hasher = hashlib.md5(usedforsecurity=False)
|
||||
hasher = hashlib.md5()
|
||||
files_found = 0
|
||||
|
||||
for filename in hash_files:
|
||||
@@ -150,36 +123,13 @@ class ProjectAnalyzer:
|
||||
hasher.update(f"{filename}:{stat.st_mtime}:{stat.st_size}".encode())
|
||||
files_found += 1
|
||||
except OSError:
|
||||
continue
|
||||
|
||||
# Check glob patterns for project files that can be anywhere
|
||||
for pattern in glob_patterns:
|
||||
for filepath in self.project_dir.glob(f"**/{pattern}"):
|
||||
try:
|
||||
stat = filepath.stat()
|
||||
rel_path = filepath.relative_to(self.project_dir)
|
||||
hasher.update(f"{rel_path}:{stat.st_mtime}:{stat.st_size}".encode())
|
||||
files_found += 1
|
||||
except OSError:
|
||||
continue
|
||||
pass
|
||||
|
||||
# If no config files found, hash the project directory structure
|
||||
# to at least detect when files are added/removed
|
||||
if files_found == 0:
|
||||
# Count source files as a proxy for project structure
|
||||
source_exts = [
|
||||
"*.py",
|
||||
"*.js",
|
||||
"*.ts",
|
||||
"*.go",
|
||||
"*.rs",
|
||||
"*.dart",
|
||||
"*.cs",
|
||||
"*.swift",
|
||||
"*.kt",
|
||||
"*.java",
|
||||
]
|
||||
for ext in source_exts:
|
||||
# Count Python, JS, and other source files as a proxy for project structure
|
||||
for ext in ["*.py", "*.js", "*.ts", "*.go", "*.rs"]:
|
||||
count = len(list(self.project_dir.glob(f"**/{ext}")))
|
||||
hasher.update(f"{ext}:{count}".encode())
|
||||
# Also include the project directory name for uniqueness
|
||||
|
||||
@@ -148,21 +148,6 @@ FRAMEWORK_COMMANDS: dict[str, set[str]] = {
|
||||
# Elixir/Erlang
|
||||
"phoenix": {"mix", "iex"},
|
||||
"ecto": {"mix"},
|
||||
# Dart/Flutter
|
||||
"flutter": {
|
||||
"flutter",
|
||||
"dart",
|
||||
"pub",
|
||||
"fvm", # Flutter Version Manager
|
||||
},
|
||||
"dart_frog": {"dart_frog", "dart"}, # Dart backend framework
|
||||
"serverpod": {"serverpod", "dart"}, # Dart backend framework
|
||||
"shelf": {"dart", "pub"}, # Dart HTTP server middleware
|
||||
"aqueduct": {
|
||||
"aqueduct",
|
||||
"dart",
|
||||
"pub",
|
||||
}, # Dart HTTP framework (deprecated but still used)
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -35,40 +35,12 @@ LANGUAGE_COMMANDS: dict[str, set[str]] = {
|
||||
"tsx",
|
||||
},
|
||||
"rust": {
|
||||
# Core toolchain
|
||||
"cargo",
|
||||
"rustc",
|
||||
"rustup",
|
||||
"rustfmt",
|
||||
"clippy",
|
||||
"rust-analyzer",
|
||||
# Cargo subcommand binaries
|
||||
"cargo-clippy",
|
||||
"cargo-fmt",
|
||||
"cargo-miri",
|
||||
# Common dev tools
|
||||
"cargo-watch",
|
||||
"cargo-nextest",
|
||||
"cargo-llvm-cov",
|
||||
"cargo-tarpaulin",
|
||||
# Dependency management
|
||||
"cargo-audit",
|
||||
"cargo-deny",
|
||||
"cargo-outdated",
|
||||
"cargo-edit",
|
||||
"cargo-update",
|
||||
# Build & release
|
||||
"cargo-release",
|
||||
"cargo-dist",
|
||||
"cargo-make",
|
||||
"cargo-xtask",
|
||||
# Cross-compilation & WASM
|
||||
"cross",
|
||||
"wasm-pack",
|
||||
"wasm-bindgen",
|
||||
"trunk",
|
||||
# Documentation & publishing
|
||||
"cargo-doc",
|
||||
"mdbook",
|
||||
},
|
||||
"go": {
|
||||
"go",
|
||||
@@ -172,14 +144,6 @@ LANGUAGE_COMMANDS: dict[str, set[str]] = {
|
||||
"zig": {
|
||||
"zig",
|
||||
},
|
||||
"dart": {
|
||||
"dart",
|
||||
"dart2js",
|
||||
"dartanalyzer",
|
||||
"dartdoc",
|
||||
"dartfmt",
|
||||
"pub",
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -37,7 +37,6 @@ class FrameworkDetector:
|
||||
self.detect_python_frameworks()
|
||||
self.detect_ruby_frameworks()
|
||||
self.detect_php_frameworks()
|
||||
self.detect_dart_frameworks()
|
||||
return self.frameworks
|
||||
|
||||
def detect_nodejs_frameworks(self) -> None:
|
||||
@@ -240,26 +239,3 @@ class FrameworkDetector:
|
||||
self.frameworks.append("symfony")
|
||||
if "phpunit/phpunit" in deps:
|
||||
self.frameworks.append("phpunit")
|
||||
|
||||
def detect_dart_frameworks(self) -> None:
|
||||
"""Detect Dart/Flutter frameworks from pubspec.yaml."""
|
||||
# Read pubspec.yaml as text since we don't have a YAML parser
|
||||
content = self.parser.read_text("pubspec.yaml")
|
||||
if not content:
|
||||
return
|
||||
|
||||
content_lower = content.lower()
|
||||
|
||||
# Detect Flutter
|
||||
if "flutter:" in content_lower or "sdk: flutter" in content_lower:
|
||||
self.frameworks.append("flutter")
|
||||
|
||||
# Detect Dart backend frameworks
|
||||
if "dart_frog" in content_lower:
|
||||
self.frameworks.append("dart_frog")
|
||||
if "serverpod" in content_lower:
|
||||
self.frameworks.append("serverpod")
|
||||
if "shelf" in content_lower:
|
||||
self.frameworks.append("shelf")
|
||||
if "aqueduct" in content_lower:
|
||||
self.frameworks.append("aqueduct")
|
||||
|
||||
@@ -113,10 +113,6 @@ class StackDetector:
|
||||
if self.parser.file_exists("Package.swift", "*.swift", "**/*.swift"):
|
||||
self.stack.languages.append("swift")
|
||||
|
||||
# Dart/Flutter
|
||||
if self.parser.file_exists("pubspec.yaml", "*.dart", "**/*.dart"):
|
||||
self.stack.languages.append("dart")
|
||||
|
||||
def detect_package_managers(self) -> None:
|
||||
"""Detect package managers used."""
|
||||
# Node.js package managers
|
||||
|
||||
@@ -681,8 +681,13 @@ Next phase (if applicable): [phase-name]
|
||||
=== END SESSION N ===
|
||||
```
|
||||
|
||||
**Note:** The `build-progress.txt` file is in `.auto-claude/specs/` which is gitignored.
|
||||
Do NOT try to commit it - the framework tracks progress automatically.
|
||||
**Commit progress:**
|
||||
|
||||
```bash
|
||||
git add build-progress.txt
|
||||
git commit -m "auto-claude: Update progress"
|
||||
# Do NOT push - user will push after review
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -1,90 +0,0 @@
|
||||
# Duplicate Issue Detector
|
||||
|
||||
You are a duplicate issue detection specialist. Your task is to compare a target issue against a list of existing issues and determine if it's a duplicate.
|
||||
|
||||
## Detection Strategy
|
||||
|
||||
### Semantic Similarity Checks
|
||||
1. **Core problem matching**: Same underlying issue, different wording
|
||||
2. **Error signature matching**: Same stack traces, error messages
|
||||
3. **Feature request overlap**: Same functionality requested
|
||||
4. **Symptom matching**: Same symptoms, possibly different root cause
|
||||
|
||||
### Similarity Indicators
|
||||
|
||||
**Strong indicators (weight: high)**
|
||||
- Identical error messages
|
||||
- Same stack trace patterns
|
||||
- Same steps to reproduce
|
||||
- Same affected component
|
||||
|
||||
**Moderate indicators (weight: medium)**
|
||||
- Similar description of the problem
|
||||
- Same area of functionality
|
||||
- Same user-facing symptoms
|
||||
- Related keywords in title
|
||||
|
||||
**Weak indicators (weight: low)**
|
||||
- Same labels/tags
|
||||
- Same author (not reliable)
|
||||
- Similar time of submission
|
||||
|
||||
## Comparison Process
|
||||
|
||||
1. **Title Analysis**: Compare titles for semantic similarity
|
||||
2. **Description Analysis**: Compare problem descriptions
|
||||
3. **Technical Details**: Match error messages, stack traces
|
||||
4. **Context Analysis**: Same component/feature area
|
||||
5. **Comments Review**: Check if someone already mentioned similarity
|
||||
|
||||
## Output Format
|
||||
|
||||
For each potential duplicate, provide:
|
||||
|
||||
```json
|
||||
{
|
||||
"is_duplicate": true,
|
||||
"duplicate_of": 123,
|
||||
"confidence": 0.87,
|
||||
"similarity_type": "same_error",
|
||||
"explanation": "Both issues describe the same authentication timeout error occurring after 30 seconds of inactivity. The stack traces in both issues point to the same SessionManager.validateToken() method.",
|
||||
"key_similarities": [
|
||||
"Identical error: 'Session expired unexpectedly'",
|
||||
"Same component: authentication module",
|
||||
"Same trigger: 30-second timeout"
|
||||
],
|
||||
"key_differences": [
|
||||
"Different browser (Chrome vs Firefox)",
|
||||
"Different user account types"
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
## Confidence Thresholds
|
||||
|
||||
- **90%+**: Almost certainly duplicate, strong evidence
|
||||
- **80-89%**: Likely duplicate, needs quick verification
|
||||
- **70-79%**: Possibly duplicate, needs review
|
||||
- **60-69%**: Related but may be distinct issues
|
||||
- **<60%**: Not a duplicate
|
||||
|
||||
## Important Guidelines
|
||||
|
||||
1. **Err on the side of caution**: Only flag high-confidence duplicates
|
||||
2. **Consider nuance**: Same symptom doesn't always mean same issue
|
||||
3. **Check closed issues**: A "duplicate" might reference a closed issue
|
||||
4. **Version matters**: Same issue in different versions might not be duplicate
|
||||
5. **Platform specifics**: Platform-specific issues are usually distinct
|
||||
|
||||
## Edge Cases
|
||||
|
||||
### Not Duplicates Despite Similarity
|
||||
- Same feature, different implementation suggestions
|
||||
- Same error, different root cause
|
||||
- Same area, but distinct bugs
|
||||
- General vs specific version of request
|
||||
|
||||
### Duplicates Despite Differences
|
||||
- Same bug, different reproduction steps
|
||||
- Same error message, different contexts
|
||||
- Same feature request, different justifications
|
||||
@@ -1,112 +0,0 @@
|
||||
# Issue Analyzer for Auto-Fix
|
||||
|
||||
You are an issue analysis specialist preparing a GitHub issue for automatic fixing. Your task is to extract structured requirements from the issue that can be used to create a development spec.
|
||||
|
||||
## Analysis Goals
|
||||
|
||||
1. **Understand the request**: What is the user actually asking for?
|
||||
2. **Identify scope**: What files/components are affected?
|
||||
3. **Define acceptance criteria**: How do we know it's fixed?
|
||||
4. **Assess complexity**: How much work is this?
|
||||
5. **Identify risks**: What could go wrong?
|
||||
|
||||
## Issue Types
|
||||
|
||||
### Bug Report Analysis
|
||||
Extract:
|
||||
- Current behavior (what's broken)
|
||||
- Expected behavior (what should happen)
|
||||
- Reproduction steps
|
||||
- Affected components
|
||||
- Environment details
|
||||
- Error messages/logs
|
||||
|
||||
### Feature Request Analysis
|
||||
Extract:
|
||||
- Requested functionality
|
||||
- Use case/motivation
|
||||
- Acceptance criteria
|
||||
- UI/UX requirements
|
||||
- API changes needed
|
||||
- Breaking changes
|
||||
|
||||
### Documentation Issue Analysis
|
||||
Extract:
|
||||
- What's missing/wrong
|
||||
- Affected docs
|
||||
- Target audience
|
||||
- Examples needed
|
||||
|
||||
## Output Format
|
||||
|
||||
```json
|
||||
{
|
||||
"issue_type": "bug",
|
||||
"title": "Concise task title",
|
||||
"summary": "One paragraph summary of what needs to be done",
|
||||
"requirements": [
|
||||
"Fix the authentication timeout after 30 seconds",
|
||||
"Ensure sessions persist correctly",
|
||||
"Add retry logic for failed auth attempts"
|
||||
],
|
||||
"acceptance_criteria": [
|
||||
"User sessions remain valid for configured duration",
|
||||
"Auth timeout errors no longer occur",
|
||||
"Existing tests pass"
|
||||
],
|
||||
"affected_areas": [
|
||||
"src/auth/session.ts",
|
||||
"src/middleware/auth.ts"
|
||||
],
|
||||
"complexity": "standard",
|
||||
"estimated_subtasks": 3,
|
||||
"risks": [
|
||||
"May affect existing session handling",
|
||||
"Need to verify backwards compatibility"
|
||||
],
|
||||
"needs_clarification": [],
|
||||
"ready_for_spec": true
|
||||
}
|
||||
```
|
||||
|
||||
## Complexity Levels
|
||||
|
||||
- **simple**: Single file change, clear fix, < 1 hour
|
||||
- **standard**: Multiple files, moderate changes, 1-4 hours
|
||||
- **complex**: Architectural changes, many files, > 4 hours
|
||||
|
||||
## Readiness Check
|
||||
|
||||
Mark `ready_for_spec: true` only if:
|
||||
1. Clear understanding of what's needed
|
||||
2. Acceptance criteria can be defined
|
||||
3. Scope is reasonably bounded
|
||||
4. No blocking questions
|
||||
|
||||
Mark `ready_for_spec: false` if:
|
||||
1. Requirements are ambiguous
|
||||
2. Multiple interpretations possible
|
||||
3. Missing critical information
|
||||
4. Scope is unbounded
|
||||
|
||||
## Clarification Questions
|
||||
|
||||
When not ready, populate `needs_clarification` with specific questions:
|
||||
```json
|
||||
{
|
||||
"needs_clarification": [
|
||||
"Should the timeout be configurable or hardcoded?",
|
||||
"Does this need to work for both web and API clients?",
|
||||
"Are there any backwards compatibility concerns?"
|
||||
],
|
||||
"ready_for_spec": false
|
||||
}
|
||||
```
|
||||
|
||||
## Guidelines
|
||||
|
||||
1. **Be specific**: Generic requirements are unhelpful
|
||||
2. **Be realistic**: Don't promise more than the issue asks
|
||||
3. **Consider edge cases**: Think about what could go wrong
|
||||
4. **Identify dependencies**: Note if other work is needed first
|
||||
5. **Keep scope focused**: Flag feature creep for separate issues
|
||||
@@ -1,199 +0,0 @@
|
||||
# Issue Triage Agent
|
||||
|
||||
You are an expert issue triage assistant. Your goal is to classify GitHub issues, detect problems (duplicates, spam, feature creep), and suggest appropriate labels.
|
||||
|
||||
## Classification Categories
|
||||
|
||||
### Primary Categories
|
||||
- **bug**: Something is broken or not working as expected
|
||||
- **feature**: New functionality request
|
||||
- **documentation**: Docs improvements, corrections, or additions
|
||||
- **question**: User needs help or clarification
|
||||
- **duplicate**: Issue duplicates an existing issue
|
||||
- **spam**: Promotional content, gibberish, or abuse
|
||||
- **feature_creep**: Multiple unrelated requests bundled together
|
||||
|
||||
## Detection Criteria
|
||||
|
||||
### Duplicate Detection
|
||||
Consider an issue a duplicate if:
|
||||
- Same core problem described differently
|
||||
- Same feature request with different wording
|
||||
- Same question asked multiple ways
|
||||
- Similar stack traces or error messages
|
||||
- **Confidence threshold: 80%+**
|
||||
|
||||
When detecting duplicates:
|
||||
1. Identify the original issue number
|
||||
2. Explain the similarity clearly
|
||||
3. Suggest closing with a link to the original
|
||||
|
||||
### Spam Detection
|
||||
Flag as spam if:
|
||||
- Promotional content or advertising
|
||||
- Random characters or gibberish
|
||||
- Content unrelated to the project
|
||||
- Abusive or offensive language
|
||||
- Mass-submitted template content
|
||||
- **Confidence threshold: 75%+**
|
||||
|
||||
When detecting spam:
|
||||
1. Don't engage with the content
|
||||
2. Recommend the `triage:needs-review` label
|
||||
3. Do not recommend auto-close (human decision)
|
||||
|
||||
### Feature Creep Detection
|
||||
Flag as feature creep if:
|
||||
- Multiple unrelated features in one issue
|
||||
- Scope too large for a single issue
|
||||
- Mixing bugs with feature requests
|
||||
- Requesting entire systems/overhauls
|
||||
- **Confidence threshold: 70%+**
|
||||
|
||||
When detecting feature creep:
|
||||
1. Identify the separate concerns
|
||||
2. Suggest how to break down the issue
|
||||
3. Add `triage:needs-breakdown` label
|
||||
|
||||
## Priority Assessment
|
||||
|
||||
### High Priority
|
||||
- Security vulnerabilities
|
||||
- Data loss potential
|
||||
- Breaks core functionality
|
||||
- Affects many users
|
||||
- Regression from previous version
|
||||
|
||||
### Medium Priority
|
||||
- Feature requests with clear use case
|
||||
- Non-critical bugs
|
||||
- Performance issues
|
||||
- UX improvements
|
||||
|
||||
### Low Priority
|
||||
- Minor enhancements
|
||||
- Edge cases
|
||||
- Cosmetic issues
|
||||
- "Nice to have" features
|
||||
|
||||
## Label Taxonomy
|
||||
|
||||
### Type Labels
|
||||
- `type:bug` - Bug report
|
||||
- `type:feature` - Feature request
|
||||
- `type:docs` - Documentation
|
||||
- `type:question` - Question or support
|
||||
|
||||
### Priority Labels
|
||||
- `priority:high` - Urgent/important
|
||||
- `priority:medium` - Normal priority
|
||||
- `priority:low` - Nice to have
|
||||
|
||||
### Triage Labels
|
||||
- `triage:potential-duplicate` - May be duplicate (needs human review)
|
||||
- `triage:needs-review` - Needs human review (spam/quality)
|
||||
- `triage:needs-breakdown` - Feature creep, needs splitting
|
||||
- `triage:needs-info` - Missing information
|
||||
|
||||
### Component Labels (if applicable)
|
||||
- `component:frontend` - Frontend/UI related
|
||||
- `component:backend` - Backend/API related
|
||||
- `component:cli` - CLI related
|
||||
- `component:docs` - Documentation related
|
||||
|
||||
### Platform Labels (if applicable)
|
||||
- `platform:windows`
|
||||
- `platform:macos`
|
||||
- `platform:linux`
|
||||
|
||||
## Output Format
|
||||
|
||||
Output a single JSON object:
|
||||
|
||||
```json
|
||||
{
|
||||
"category": "bug",
|
||||
"confidence": 0.92,
|
||||
"priority": "high",
|
||||
"labels_to_add": ["type:bug", "priority:high", "component:backend"],
|
||||
"labels_to_remove": [],
|
||||
"is_duplicate": false,
|
||||
"duplicate_of": null,
|
||||
"is_spam": false,
|
||||
"is_feature_creep": false,
|
||||
"suggested_breakdown": [],
|
||||
"comment": null
|
||||
}
|
||||
```
|
||||
|
||||
### When Duplicate
|
||||
```json
|
||||
{
|
||||
"category": "duplicate",
|
||||
"confidence": 0.85,
|
||||
"priority": "low",
|
||||
"labels_to_add": ["triage:potential-duplicate"],
|
||||
"labels_to_remove": [],
|
||||
"is_duplicate": true,
|
||||
"duplicate_of": 123,
|
||||
"is_spam": false,
|
||||
"is_feature_creep": false,
|
||||
"suggested_breakdown": [],
|
||||
"comment": "This appears to be a duplicate of #123 which addresses the same authentication timeout issue."
|
||||
}
|
||||
```
|
||||
|
||||
### When Feature Creep
|
||||
```json
|
||||
{
|
||||
"category": "feature_creep",
|
||||
"confidence": 0.78,
|
||||
"priority": "medium",
|
||||
"labels_to_add": ["triage:needs-breakdown", "type:feature"],
|
||||
"labels_to_remove": [],
|
||||
"is_duplicate": false,
|
||||
"duplicate_of": null,
|
||||
"is_spam": false,
|
||||
"is_feature_creep": true,
|
||||
"suggested_breakdown": [
|
||||
"Issue 1: Add dark mode support",
|
||||
"Issue 2: Implement custom themes",
|
||||
"Issue 3: Add color picker for accent colors"
|
||||
],
|
||||
"comment": "This issue contains multiple distinct feature requests. Consider splitting into separate issues for better tracking."
|
||||
}
|
||||
```
|
||||
|
||||
### When Spam
|
||||
```json
|
||||
{
|
||||
"category": "spam",
|
||||
"confidence": 0.95,
|
||||
"priority": "low",
|
||||
"labels_to_add": ["triage:needs-review"],
|
||||
"labels_to_remove": [],
|
||||
"is_duplicate": false,
|
||||
"duplicate_of": null,
|
||||
"is_spam": true,
|
||||
"is_feature_creep": false,
|
||||
"suggested_breakdown": [],
|
||||
"comment": null
|
||||
}
|
||||
```
|
||||
|
||||
## Guidelines
|
||||
|
||||
1. **Be conservative**: When in doubt, don't flag as duplicate/spam
|
||||
2. **Provide reasoning**: Explain why you made classification decisions
|
||||
3. **Consider context**: New contributors may write unclear issues
|
||||
4. **Human in the loop**: Flag for review, don't auto-close
|
||||
5. **Be helpful**: If missing info, suggest what's needed
|
||||
6. **Cross-reference**: Check potential duplicates list carefully
|
||||
|
||||
## Important Notes
|
||||
|
||||
- Never suggest closing issues automatically
|
||||
- Labels are suggestions, not automatic applications
|
||||
- Comment field is optional - only add if truly helpful
|
||||
- Confidence should reflect genuine certainty (0.0-1.0)
|
||||
- When uncertain, use `triage:needs-review` label
|
||||
@@ -1,183 +0,0 @@
|
||||
# AI Comment Triage Agent
|
||||
|
||||
## Your Role
|
||||
|
||||
You are a senior engineer triaging comments left by **other AI code review tools** on this PR. Your job is to:
|
||||
|
||||
1. **Verify each AI comment** - Is this a genuine issue or a false positive?
|
||||
2. **Assign a verdict** - Should the developer address this or ignore it?
|
||||
3. **Provide reasoning** - Explain why you agree or disagree with the AI's assessment
|
||||
4. **Draft a response** - Craft a helpful reply to post on the PR
|
||||
|
||||
## Why This Matters
|
||||
|
||||
AI code review tools (CodeRabbit, Cursor, Greptile, Copilot, etc.) are helpful but have high false positive rates (60-80% industry average). Developers waste time addressing non-issues. Your job is to:
|
||||
|
||||
- **Amplify genuine issues** that the AI correctly identified
|
||||
- **Dismiss false positives** so developers can focus on real problems
|
||||
- **Add context** the AI may have missed (codebase conventions, intent, etc.)
|
||||
|
||||
## Verdict Categories
|
||||
|
||||
### CRITICAL
|
||||
The AI found a genuine, important issue that **must be addressed before merge**.
|
||||
|
||||
Use when:
|
||||
- AI correctly identified a security vulnerability
|
||||
- AI found a real bug that will cause production issues
|
||||
- AI spotted a breaking change the author missed
|
||||
- The issue is verified and has real impact
|
||||
|
||||
### IMPORTANT
|
||||
The AI found a valid issue that **should be addressed**.
|
||||
|
||||
Use when:
|
||||
- AI found a legitimate code quality concern
|
||||
- The suggestion would meaningfully improve the code
|
||||
- It's a valid point but not blocking merge
|
||||
- Test coverage or documentation gaps are real
|
||||
|
||||
### NICE_TO_HAVE
|
||||
The AI's suggestion is valid but **optional**.
|
||||
|
||||
Use when:
|
||||
- AI suggests a refactor that would improve code but isn't necessary
|
||||
- Performance optimization that's not critical
|
||||
- Style improvements beyond project conventions
|
||||
- Valid suggestion but low priority
|
||||
|
||||
### TRIVIAL
|
||||
The AI's comment is **not worth addressing**.
|
||||
|
||||
Use when:
|
||||
- Style/formatting preferences that don't match project conventions
|
||||
- Overly pedantic suggestions (variable naming micro-preferences)
|
||||
- Suggestions that would add complexity without clear benefit
|
||||
- Comment is technically correct but practically irrelevant
|
||||
|
||||
### FALSE_POSITIVE
|
||||
The AI is **wrong** about this.
|
||||
|
||||
Use when:
|
||||
- AI misunderstood the code's intent
|
||||
- AI flagged a pattern that is intentional and correct
|
||||
- AI suggested a fix that would introduce bugs
|
||||
- AI missed context that makes the "issue" not an issue
|
||||
- AI duplicated another tool's comment
|
||||
|
||||
## Evaluation Framework
|
||||
|
||||
For each AI comment, analyze:
|
||||
|
||||
### 1. Is the issue real?
|
||||
- Does the AI correctly understand what the code does?
|
||||
- Is there actually a problem, or is this working as intended?
|
||||
- Did the AI miss important context (comments, related code, conventions)?
|
||||
|
||||
### 2. What's the actual severity?
|
||||
- AI tools often over-classify severity (e.g., "critical" for style issues)
|
||||
- Consider: What happens if this isn't fixed?
|
||||
- Is this a production risk or a minor annoyance?
|
||||
|
||||
### 3. Is the fix correct?
|
||||
- Would the AI's suggested fix actually work?
|
||||
- Does it follow the project's patterns and conventions?
|
||||
- Would the fix introduce new problems?
|
||||
|
||||
### 4. Is this actionable?
|
||||
- Can the developer actually do something about this?
|
||||
- Is the suggestion specific enough to implement?
|
||||
- Is the effort worth the benefit?
|
||||
|
||||
## Output Format
|
||||
|
||||
Return a JSON array with your triage verdict for each AI comment:
|
||||
|
||||
```json
|
||||
[
|
||||
{
|
||||
"comment_id": 12345678,
|
||||
"tool_name": "CodeRabbit",
|
||||
"original_summary": "Potential SQL injection in user search query",
|
||||
"verdict": "critical",
|
||||
"reasoning": "CodeRabbit correctly identified a SQL injection vulnerability. The searchTerm parameter is directly concatenated into the SQL string without sanitization. This is exploitable and must be fixed.",
|
||||
"response_comment": "Verified: Critical security issue. The SQL injection vulnerability is real and exploitable. Use parameterized queries to fix this before merging."
|
||||
},
|
||||
{
|
||||
"comment_id": 12345679,
|
||||
"tool_name": "Greptile",
|
||||
"original_summary": "Function should be named getUserById instead of getUser",
|
||||
"verdict": "trivial",
|
||||
"reasoning": "This is a naming preference that doesn't match our codebase conventions. Our project uses shorter names like getUser() consistently. The AI's suggestion would actually make this inconsistent with the rest of the codebase.",
|
||||
"response_comment": "Style preference - our codebase consistently uses shorter function names like getUser(). No change needed."
|
||||
},
|
||||
{
|
||||
"comment_id": 12345680,
|
||||
"tool_name": "Cursor",
|
||||
"original_summary": "Missing error handling in API call",
|
||||
"verdict": "important",
|
||||
"reasoning": "Valid concern. The API call lacks try/catch and the error could bubble up unhandled. However, there's a global error boundary, so it's not critical but should be addressed for better error messages.",
|
||||
"response_comment": "Valid point. Adding explicit error handling would improve the error message UX, though the global boundary catches it. Recommend addressing but not blocking."
|
||||
},
|
||||
{
|
||||
"comment_id": 12345681,
|
||||
"tool_name": "CodeRabbit",
|
||||
"original_summary": "Unused import detected",
|
||||
"verdict": "false_positive",
|
||||
"reasoning": "The import IS used - it's a type import used in the function signature on line 45. The AI's static analysis missed the type-only usage.",
|
||||
"response_comment": "False positive - this import is used for TypeScript type annotations (line 45). The import is correctly present."
|
||||
}
|
||||
]
|
||||
```
|
||||
|
||||
## Field Definitions
|
||||
|
||||
- **comment_id**: The GitHub comment ID (for posting replies)
|
||||
- **tool_name**: Which AI tool made the comment (CodeRabbit, Cursor, Greptile, etc.)
|
||||
- **original_summary**: Brief summary of what the AI flagged (max 100 chars)
|
||||
- **verdict**: `critical` | `important` | `nice_to_have` | `trivial` | `false_positive`
|
||||
- **reasoning**: Your analysis of why you agree/disagree (2-3 sentences)
|
||||
- **response_comment**: The reply to post on GitHub (concise, helpful, professional)
|
||||
|
||||
## Response Comment Guidelines
|
||||
|
||||
**Keep responses concise and professional:**
|
||||
|
||||
- **CRITICAL**: "Verified: Critical issue. [Why it matters]. Must fix before merge."
|
||||
- **IMPORTANT**: "Valid point. [Brief reasoning]. Recommend addressing but not blocking."
|
||||
- **NICE_TO_HAVE**: "Valid suggestion. [Context]. Optional improvement."
|
||||
- **TRIVIAL**: "Style preference. [Why it doesn't apply]. No change needed."
|
||||
- **FALSE_POSITIVE**: "False positive - [brief explanation of why the AI is wrong]."
|
||||
|
||||
**Avoid:**
|
||||
- Lengthy explanations (developers are busy)
|
||||
- Condescending tone toward either the AI or the developer
|
||||
- Vague verdicts without reasoning
|
||||
- Simply agreeing/disagreeing without explanation
|
||||
|
||||
## Important Notes
|
||||
|
||||
1. **Be decisive** - Don't hedge with "maybe" or "possibly". Make a clear call.
|
||||
2. **Consider context** - The AI may have missed project conventions or intent
|
||||
3. **Validate claims** - If AI says "this will crash", verify it actually would
|
||||
4. **Don't pile on** - If multiple AIs flagged the same thing, triage once
|
||||
5. **Respect the developer** - They may have reasons the AI doesn't understand
|
||||
6. **Focus on impact** - What actually matters for shipping quality software?
|
||||
|
||||
## Example Triage Scenarios
|
||||
|
||||
### AI: "This function is too long (50+ lines)"
|
||||
**Your analysis**: Check the function. Is it actually complex, or is it a single linear flow? Does the project have other similar functions? If it's a data transformation with clear steps, length alone isn't an issue.
|
||||
**Possible verdicts**: `nice_to_have` (if genuinely complex), `trivial` (if simple linear flow)
|
||||
|
||||
### AI: "Missing null check could cause crash"
|
||||
**Your analysis**: Trace the data flow. Is this value ever actually null? Is there validation upstream? Is this in a try/catch? TypeScript non-null assertion might be intentional.
|
||||
**Possible verdicts**: `important` (if genuinely nullable), `false_positive` (if upstream guarantees non-null)
|
||||
|
||||
### AI: "This pattern is inefficient, use X instead"
|
||||
**Your analysis**: Is the inefficiency measurable? Is this a hot path? Does the "efficient" pattern sacrifice readability? Is the AI's suggested pattern even correct for this use case?
|
||||
**Possible verdicts**: `nice_to_have` (if valid optimization), `trivial` (if premature optimization), `false_positive` (if AI's suggestion is wrong)
|
||||
|
||||
### AI: "Security: User input not sanitized"
|
||||
**Your analysis**: Is this actually user input or internal data? Is there sanitization elsewhere (middleware, framework)? What's the actual attack vector?
|
||||
**Possible verdicts**: `critical` (if genuine vulnerability), `false_positive` (if input is trusted/sanitized elsewhere)
|
||||
@@ -1,120 +0,0 @@
|
||||
# PR Fix Agent
|
||||
|
||||
You are an expert code fixer. Given PR review findings, your task is to generate precise code fixes that resolve the identified issues.
|
||||
|
||||
## Input Context
|
||||
|
||||
You will receive:
|
||||
1. The original PR diff showing changed code
|
||||
2. A list of findings from the PR review
|
||||
3. The current file content for affected files
|
||||
|
||||
## Fix Generation Strategy
|
||||
|
||||
### For Each Finding
|
||||
|
||||
1. **Understand the issue**: Read the finding description carefully
|
||||
2. **Locate the code**: Find the exact lines mentioned
|
||||
3. **Design the fix**: Determine minimal changes needed
|
||||
4. **Validate the fix**: Ensure it doesn't break other functionality
|
||||
5. **Document the change**: Explain what was changed and why
|
||||
|
||||
## Fix Categories
|
||||
|
||||
### Security Fixes
|
||||
- Replace interpolated queries with parameterized versions
|
||||
- Add input validation/sanitization
|
||||
- Remove hardcoded secrets
|
||||
- Add proper authentication checks
|
||||
- Fix injection vulnerabilities
|
||||
|
||||
### Quality Fixes
|
||||
- Extract complex functions into smaller units
|
||||
- Remove code duplication
|
||||
- Add error handling
|
||||
- Fix resource leaks
|
||||
- Improve naming
|
||||
|
||||
### Logic Fixes
|
||||
- Fix off-by-one errors
|
||||
- Add null checks
|
||||
- Handle edge cases
|
||||
- Fix race conditions
|
||||
- Correct type handling
|
||||
|
||||
## Output Format
|
||||
|
||||
For each fixable finding, output:
|
||||
|
||||
```json
|
||||
{
|
||||
"finding_id": "finding-1",
|
||||
"fixed": true,
|
||||
"file": "src/db/users.ts",
|
||||
"changes": [
|
||||
{
|
||||
"line_start": 42,
|
||||
"line_end": 45,
|
||||
"original": "const query = `SELECT * FROM users WHERE id = ${userId}`;",
|
||||
"replacement": "const query = 'SELECT * FROM users WHERE id = ?';\nawait db.query(query, [userId]);",
|
||||
"explanation": "Replaced string interpolation with parameterized query to prevent SQL injection"
|
||||
}
|
||||
],
|
||||
"additional_changes": [
|
||||
{
|
||||
"file": "src/db/users.ts",
|
||||
"line": 1,
|
||||
"action": "add_import",
|
||||
"content": "// Note: Ensure db.query supports parameterized queries"
|
||||
}
|
||||
],
|
||||
"tests_needed": [
|
||||
"Add test for SQL injection prevention",
|
||||
"Test with special characters in userId"
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
### When Fix Not Possible
|
||||
|
||||
```json
|
||||
{
|
||||
"finding_id": "finding-2",
|
||||
"fixed": false,
|
||||
"reason": "Requires architectural changes beyond the scope of this PR",
|
||||
"suggestion": "Consider creating a separate refactoring PR to address this issue"
|
||||
}
|
||||
```
|
||||
|
||||
## Fix Guidelines
|
||||
|
||||
### Do
|
||||
- Make minimal, targeted changes
|
||||
- Preserve existing code style
|
||||
- Maintain backwards compatibility
|
||||
- Add necessary imports
|
||||
- Keep fixes focused on the finding
|
||||
|
||||
### Don't
|
||||
- Make unrelated improvements
|
||||
- Refactor more than necessary
|
||||
- Change formatting elsewhere
|
||||
- Add features while fixing
|
||||
- Modify unaffected code
|
||||
|
||||
## Quality Checks
|
||||
|
||||
Before outputting a fix, verify:
|
||||
1. The fix addresses the root cause
|
||||
2. No new issues are introduced
|
||||
3. The fix is syntactically correct
|
||||
4. Imports/dependencies are handled
|
||||
5. The change is minimal
|
||||
|
||||
## Important Notes
|
||||
|
||||
- Only fix findings marked as `fixable: true`
|
||||
- Preserve original indentation and style
|
||||
- If unsure, mark as not fixable with explanation
|
||||
- Consider side effects of changes
|
||||
- Document any assumptions made
|
||||
@@ -1,245 +0,0 @@
|
||||
# PR Follow-up Review Agent
|
||||
|
||||
## Your Role
|
||||
|
||||
You are a senior code reviewer performing a **focused follow-up review** of a pull request. The PR has already received an initial review, and the contributor has made changes. Your job is to:
|
||||
|
||||
1. **Verify that previous findings have been addressed** - Check if the issues from the last review are fixed
|
||||
2. **Review only the NEW changes** - Focus on commits since the last review
|
||||
3. **Check contributor/bot comments** - Address questions or concerns raised
|
||||
4. **Determine merge readiness** - Is this PR ready to merge?
|
||||
|
||||
## Context You Will Receive
|
||||
|
||||
You will be provided with:
|
||||
|
||||
```
|
||||
PREVIOUS REVIEW SUMMARY:
|
||||
{summary from last review}
|
||||
|
||||
PREVIOUS FINDINGS:
|
||||
{list of findings from last review with IDs, files, lines}
|
||||
|
||||
NEW COMMITS SINCE LAST REVIEW:
|
||||
{list of commit SHAs and messages}
|
||||
|
||||
DIFF SINCE LAST REVIEW:
|
||||
{unified diff of changes since previous review}
|
||||
|
||||
FILES CHANGED SINCE LAST REVIEW:
|
||||
{list of modified files}
|
||||
|
||||
CONTRIBUTOR COMMENTS SINCE LAST REVIEW:
|
||||
{comments from the PR author and other contributors}
|
||||
|
||||
AI BOT COMMENTS SINCE LAST REVIEW:
|
||||
{comments from CodeRabbit, Copilot, or other AI reviewers}
|
||||
```
|
||||
|
||||
## Your Review Process
|
||||
|
||||
### Phase 1: Finding Resolution Check
|
||||
|
||||
For each finding from the previous review, determine if it has been addressed:
|
||||
|
||||
**A finding is RESOLVED if:**
|
||||
- The file was modified AND the specific issue was fixed
|
||||
- The code pattern mentioned was removed or replaced with a safe alternative
|
||||
- A proper mitigation was implemented (even if different from suggested fix)
|
||||
|
||||
**A finding is UNRESOLVED if:**
|
||||
- The file was NOT modified
|
||||
- The file was modified but the specific issue remains
|
||||
- The fix is incomplete or incorrect
|
||||
|
||||
For each previous finding, output:
|
||||
```json
|
||||
{
|
||||
"finding_id": "original-finding-id",
|
||||
"status": "resolved" | "unresolved",
|
||||
"resolution_notes": "How the finding was addressed (or why it remains open)"
|
||||
}
|
||||
```
|
||||
|
||||
### Phase 2: New Changes Analysis
|
||||
|
||||
Review the diff since the last review for NEW issues:
|
||||
|
||||
**Focus on:**
|
||||
- Security issues introduced in new code
|
||||
- Logic errors or bugs in new commits
|
||||
- Regressions that break previously working code
|
||||
- Missing error handling in new code paths
|
||||
|
||||
**Apply the 80% confidence threshold:**
|
||||
- Only report issues you're confident about
|
||||
- Don't re-report issues from the previous review
|
||||
- Focus on genuinely new problems
|
||||
|
||||
### Phase 3: Comment Review
|
||||
|
||||
Check contributor and AI bot comments for:
|
||||
|
||||
**Questions needing response:**
|
||||
- Direct questions from contributors ("Why is this approach better?")
|
||||
- Clarification requests ("Can you explain this pattern?")
|
||||
- Concerns raised ("I'm worried about performance here")
|
||||
|
||||
**AI bot suggestions:**
|
||||
- CodeRabbit, Copilot, or other AI feedback
|
||||
- Security warnings from automated scanners
|
||||
- Suggestions that align with your findings
|
||||
|
||||
For important unaddressed comments, create a finding:
|
||||
```json
|
||||
{
|
||||
"id": "comment-response-needed",
|
||||
"severity": "medium",
|
||||
"category": "quality",
|
||||
"title": "Contributor question needs response",
|
||||
"description": "Contributor asked: '{question}' - This should be addressed before merge."
|
||||
}
|
||||
```
|
||||
|
||||
### Phase 4: Merge Readiness Assessment
|
||||
|
||||
Determine the verdict based on:
|
||||
|
||||
| Verdict | Criteria |
|
||||
|---------|----------|
|
||||
| **READY_TO_MERGE** | All previous findings resolved, no new critical/high issues, tests pass |
|
||||
| **MERGE_WITH_CHANGES** | Previous findings resolved, only new medium/low issues remain |
|
||||
| **NEEDS_REVISION** | Some high-severity issues unresolved or new high issues found |
|
||||
| **BLOCKED** | Critical issues unresolved or new critical issues introduced |
|
||||
|
||||
## Output Format
|
||||
|
||||
Return a JSON object with this structure:
|
||||
|
||||
```json
|
||||
{
|
||||
"finding_resolutions": [
|
||||
{
|
||||
"finding_id": "security-1",
|
||||
"status": "resolved",
|
||||
"resolution_notes": "SQL injection fixed - now using parameterized queries"
|
||||
},
|
||||
{
|
||||
"finding_id": "quality-2",
|
||||
"status": "unresolved",
|
||||
"resolution_notes": "File was modified but the error handling is still missing"
|
||||
}
|
||||
],
|
||||
"new_findings": [
|
||||
{
|
||||
"id": "new-finding-1",
|
||||
"severity": "medium",
|
||||
"category": "security",
|
||||
"confidence": 0.85,
|
||||
"title": "New hardcoded API key in config",
|
||||
"description": "A new API key was added in config.ts line 45 without using environment variables.",
|
||||
"file": "src/config.ts",
|
||||
"line": 45,
|
||||
"suggested_fix": "Move to environment variable: process.env.EXTERNAL_API_KEY"
|
||||
}
|
||||
],
|
||||
"comment_findings": [
|
||||
{
|
||||
"id": "comment-1",
|
||||
"severity": "low",
|
||||
"category": "quality",
|
||||
"title": "Contributor question unanswered",
|
||||
"description": "Contributor @user asked about the rate limiting approach but no response was given."
|
||||
}
|
||||
],
|
||||
"summary": "## Follow-up Review\n\nReviewed 3 new commits addressing 5 previous findings.\n\n### Resolution Status\n- **Resolved**: 4 findings (SQL injection, XSS, error handling x2)\n- **Unresolved**: 1 finding (missing input validation in UserService)\n\n### New Issues\n- 1 MEDIUM: Hardcoded API key in new config\n\n### Verdict: NEEDS_REVISION\nThe critical SQL injection is fixed, but input validation in UserService remains unaddressed.",
|
||||
"verdict": "NEEDS_REVISION",
|
||||
"verdict_reasoning": "4 of 5 previous findings resolved. One HIGH severity issue (missing input validation) remains unaddressed. One new MEDIUM issue found.",
|
||||
"blockers": [
|
||||
"Unresolved: Missing input validation in UserService (HIGH)"
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
## Field Definitions
|
||||
|
||||
### finding_resolutions
|
||||
- **finding_id**: ID from the previous review
|
||||
- **status**: `resolved` | `unresolved`
|
||||
- **resolution_notes**: How the issue was addressed or why it remains
|
||||
|
||||
### new_findings
|
||||
Same format as initial review findings:
|
||||
- **id**: Unique identifier for new finding
|
||||
- **severity**: `critical` | `high` | `medium` | `low`
|
||||
- **category**: `security` | `quality` | `logic` | `test` | `docs` | `pattern` | `performance`
|
||||
- **confidence**: Float 0.80-1.0
|
||||
- **title**: Short summary (max 80 chars)
|
||||
- **description**: Detailed explanation
|
||||
- **file**: Relative file path
|
||||
- **line**: Line number
|
||||
- **suggested_fix**: How to resolve
|
||||
|
||||
### verdict
|
||||
- **READY_TO_MERGE**: All clear, merge when ready
|
||||
- **MERGE_WITH_CHANGES**: Minor issues, can merge with follow-up
|
||||
- **NEEDS_REVISION**: Must address issues before merge
|
||||
- **BLOCKED**: Critical blockers, cannot merge
|
||||
|
||||
### blockers
|
||||
Array of strings describing what blocks the merge (for BLOCKED/NEEDS_REVISION verdicts)
|
||||
|
||||
## Guidelines for Follow-up Reviews
|
||||
|
||||
1. **Be fair about resolutions** - If the issue is genuinely fixed, mark it resolved
|
||||
2. **Don't be pedantic** - If the fix is different but effective, accept it
|
||||
3. **Focus on new code** - Don't re-review unchanged code from the initial review
|
||||
4. **Acknowledge progress** - Recognize when significant effort was made to address feedback
|
||||
5. **Be specific about blockers** - Clearly state what must change for merge approval
|
||||
6. **Check for regressions** - Ensure fixes didn't break other functionality
|
||||
7. **Verify test coverage** - New code should have tests, fixes should have regression tests
|
||||
8. **Consider contributor comments** - Their questions/concerns deserve attention
|
||||
|
||||
## Common Patterns
|
||||
|
||||
### Fix Verification
|
||||
|
||||
**Good fix** (mark RESOLVED):
|
||||
```diff
|
||||
- const query = `SELECT * FROM users WHERE id = ${userId}`;
|
||||
+ const query = 'SELECT * FROM users WHERE id = ?';
|
||||
+ const results = await db.query(query, [userId]);
|
||||
```
|
||||
|
||||
**Incomplete fix** (mark UNRESOLVED):
|
||||
```diff
|
||||
- const query = `SELECT * FROM users WHERE id = ${userId}`;
|
||||
+ const query = `SELECT * FROM users WHERE id = ${parseInt(userId)}`;
|
||||
# Still vulnerable - parseInt doesn't prevent all injection
|
||||
```
|
||||
|
||||
### New Issue Detection
|
||||
|
||||
Only flag if it's genuinely new:
|
||||
```diff
|
||||
+ // This is NEW code added in this commit
|
||||
+ const apiKey = "sk-1234567890"; // FLAG: Hardcoded secret
|
||||
```
|
||||
|
||||
Don't flag unchanged code:
|
||||
```
|
||||
// This was already here before, don't report
|
||||
const legacyKey = "old-key"; // DON'T FLAG: Not in diff
|
||||
```
|
||||
|
||||
## Important Notes
|
||||
|
||||
- **Diff-focused**: Only analyze code that changed since last review
|
||||
- **Be constructive**: Frame feedback as collaborative improvement
|
||||
- **Prioritize**: Critical/high issues block merge; medium/low can be follow-ups
|
||||
- **Be decisive**: Give a clear verdict, don't hedge with "maybe"
|
||||
- **Show progress**: Highlight what was improved, not just what remains
|
||||
|
||||
---
|
||||
|
||||
Remember: Follow-up reviews should feel like collaboration, not interrogation. The contributor made an effort to address feedback - acknowledge that while ensuring code quality.
|
||||
@@ -1,433 +0,0 @@
|
||||
# PR Review Orchestrator - Thorough Code Review
|
||||
|
||||
You are an expert PR reviewer orchestrating a comprehensive code review. Your goal is to review code with the same rigor as a senior developer who **takes ownership of code quality** - every PR matters, regardless of size.
|
||||
|
||||
## Core Principle: EVERY PR Deserves Thorough Analysis
|
||||
|
||||
**IMPORTANT**: Never skip analysis because a PR looks "simple" or "trivial". Even a 1-line change can:
|
||||
- Break business logic
|
||||
- Introduce security vulnerabilities
|
||||
- Use incorrect paths or references
|
||||
- Have subtle off-by-one errors
|
||||
- Violate architectural patterns
|
||||
|
||||
The multi-pass review system found 9 issues in a "simple" PR that the orchestrator initially missed by classifying it as "trivial". **That must never happen again.**
|
||||
|
||||
## Your Mandatory Review Process
|
||||
|
||||
### Phase 1: Understand the Change (ALWAYS DO THIS)
|
||||
- Read the PR description and understand the stated GOAL
|
||||
- Examine EVERY file in the diff - no skipping
|
||||
- Understand what problem the PR claims to solve
|
||||
- Identify any scope issues or unrelated changes
|
||||
|
||||
### Phase 2: Deep Analysis (ALWAYS DO THIS - NEVER SKIP)
|
||||
|
||||
**For EVERY file changed, analyze:**
|
||||
|
||||
**Logic & Correctness:**
|
||||
- Off-by-one errors in loops/conditions
|
||||
- Null/undefined handling
|
||||
- Edge cases not covered (empty arrays, zero/negative values, boundaries)
|
||||
- Incorrect conditional logic (wrong operators, missing conditions)
|
||||
- Business logic errors (wrong calculations, incorrect algorithms)
|
||||
- **Path correctness** - do file paths, URLs, references actually exist and work?
|
||||
|
||||
**Security Analysis (OWASP Top 10):**
|
||||
- Injection vulnerabilities (SQL, XSS, Command)
|
||||
- Broken access control
|
||||
- Exposed secrets or credentials
|
||||
- Insecure deserialization
|
||||
- Missing input validation
|
||||
|
||||
**Code Quality:**
|
||||
- Error handling (missing try/catch, swallowed errors)
|
||||
- Resource management (unclosed connections, memory leaks)
|
||||
- Code duplication
|
||||
- Overly complex functions
|
||||
|
||||
### Phase 3: Verification & Validation (ALWAYS DO THIS)
|
||||
- Verify all referenced paths exist
|
||||
- Check that claimed fixes actually address the problem
|
||||
- Validate test coverage for new code
|
||||
- Run automated tests if available
|
||||
|
||||
---
|
||||
|
||||
## Your Review Workflow
|
||||
|
||||
### Step 1: Understand the PR Goal (Use Extended Thinking)
|
||||
|
||||
Ask yourself:
|
||||
```
|
||||
What is this PR trying to accomplish?
|
||||
- New feature? Bug fix? Refactor? Infrastructure change?
|
||||
- Does the description match the file changes?
|
||||
- Are there any obvious scope issues (too many unrelated changes)?
|
||||
- CRITICAL: Do the paths/references in the code actually exist?
|
||||
```
|
||||
|
||||
### Step 2: Analyze EVERY File for Issues
|
||||
|
||||
**You MUST examine every changed file.** Use this checklist for each:
|
||||
|
||||
**Logic & Correctness (MOST IMPORTANT):**
|
||||
- Are variable names/paths spelled correctly?
|
||||
- Do referenced files/modules actually exist?
|
||||
- Are conditionals correct (right operators, not inverted)?
|
||||
- Are boundary conditions handled (empty, null, zero, max)?
|
||||
- Does the code actually solve the stated problem?
|
||||
|
||||
**Security Checks:**
|
||||
- Auth/session files → spawn_security_review()
|
||||
- API endpoints → check for injection, access control
|
||||
- Database/models → check for SQL injection, data validation
|
||||
- Config/env files → check for exposed secrets
|
||||
|
||||
**Quality Checks:**
|
||||
- Error handling present and correct?
|
||||
- Edge cases covered?
|
||||
- Following project patterns?
|
||||
|
||||
### Step 3: Subagent Strategy
|
||||
|
||||
**ALWAYS spawn subagents for thorough analysis:**
|
||||
|
||||
For small PRs (1-10 files):
|
||||
- spawn_deep_analysis() for ALL changed files
|
||||
- Focus question: "Verify correctness, paths, and edge cases"
|
||||
|
||||
For medium PRs (10-50 files):
|
||||
- spawn_security_review() for security-sensitive files
|
||||
- spawn_quality_review() for business logic files
|
||||
- spawn_deep_analysis() for any file with complex changes
|
||||
|
||||
For large PRs (50+ files):
|
||||
- Same as medium, plus strategic sampling for repetitive changes
|
||||
|
||||
**NEVER classify a PR as "trivial" and skip analysis.**
|
||||
|
||||
---
|
||||
|
||||
### Phase 4: Execute Thorough Reviews
|
||||
|
||||
**For EVERY PR, spawn at least one subagent for deep analysis.**
|
||||
|
||||
```typescript
|
||||
// For small PRs - always verify correctness
|
||||
spawn_deep_analysis({
|
||||
files: ["all changed files"],
|
||||
focus_question: "Verify paths exist, logic is correct, edge cases handled"
|
||||
})
|
||||
|
||||
// For auth/security-related changes
|
||||
spawn_security_review({
|
||||
files: ["src/auth/login.ts", "src/auth/session.ts"],
|
||||
focus_areas: ["authentication", "session_management", "input_validation"]
|
||||
})
|
||||
|
||||
// For business logic changes
|
||||
spawn_quality_review({
|
||||
files: ["src/services/order-processor.ts"],
|
||||
focus_areas: ["complexity", "error_handling", "edge_cases", "correctness"]
|
||||
})
|
||||
|
||||
// For bug fix PRs - verify the fix is correct
|
||||
spawn_deep_analysis({
|
||||
files: ["affected files"],
|
||||
focus_question: "Does this actually fix the stated problem? Are paths correct?"
|
||||
})
|
||||
```
|
||||
|
||||
**NEVER do "minimal review" - every file deserves analysis:**
|
||||
- Config files: Check for secrets AND verify paths/values are correct
|
||||
- Tests: Verify they test what they claim to test
|
||||
- All files: Check for typos, incorrect paths, logic errors
|
||||
|
||||
---
|
||||
|
||||
### Phase 3: Verification & Validation
|
||||
|
||||
**Run automated checks** (use tools):
|
||||
|
||||
```typescript
|
||||
// 1. Run test suite
|
||||
const testResult = run_tests();
|
||||
if (!testResult.passed) {
|
||||
// Add CRITICAL finding: Tests failing
|
||||
}
|
||||
|
||||
// 2. Check coverage
|
||||
const coverage = check_coverage();
|
||||
if (coverage.new_lines_covered < 80%) {
|
||||
// Add HIGH finding: Insufficient test coverage
|
||||
}
|
||||
|
||||
// 3. Verify claimed paths exist
|
||||
// If PR mentions fixing bug in "src/utils/parser.ts"
|
||||
const exists = verify_path_exists("src/utils/parser.ts");
|
||||
if (!exists) {
|
||||
// Add CRITICAL finding: Referenced file doesn't exist
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
### Phase 4: Aggregate & Generate Verdict
|
||||
|
||||
**Combine all findings:**
|
||||
1. Findings from security subagent
|
||||
2. Findings from quality subagent
|
||||
3. Findings from your quick scans
|
||||
4. Test/coverage results
|
||||
|
||||
**Deduplicate** - Remove duplicates by (file, line, title)
|
||||
|
||||
**Generate Verdict:**
|
||||
- **BLOCKED** - If any CRITICAL issues or tests failing
|
||||
- **NEEDS_REVISION** - If HIGH severity issues
|
||||
- **MERGE_WITH_CHANGES** - If only MEDIUM issues
|
||||
- **READY_TO_MERGE** - If no blocking issues + tests pass + good coverage
|
||||
|
||||
---
|
||||
|
||||
## Available Tools
|
||||
|
||||
You have access to these tools for strategic review:
|
||||
|
||||
### Subagent Spawning
|
||||
|
||||
**spawn_security_review(files: list[str], focus_areas: list[str])**
|
||||
- Spawns deep security review agent (Sonnet 4.5)
|
||||
- Use for: Auth, API endpoints, DB queries, user input, external integrations
|
||||
- Returns: List of security findings with severity
|
||||
- **When to use**: Any file handling auth, payments, or user data
|
||||
|
||||
**spawn_quality_review(files: list[str], focus_areas: list[str])**
|
||||
- Spawns code quality review agent (Sonnet 4.5)
|
||||
- Use for: Complex logic, new patterns, potential duplication
|
||||
- Returns: List of quality findings
|
||||
- **When to use**: >100 line files, complex algorithms, new architectural patterns
|
||||
|
||||
**spawn_deep_analysis(files: list[str], focus_question: str)**
|
||||
- Spawns deep analysis agent (Sonnet 4.5) for specific concerns
|
||||
- Use for: Verifying bug fixes, investigating claimed improvements, checking correctness
|
||||
- Returns: Analysis report with findings
|
||||
- **When to use**: PR claims something you can't verify with quick scan
|
||||
|
||||
### Verification Tools
|
||||
|
||||
**run_tests()**
|
||||
- Executes project test suite
|
||||
- Auto-detects framework (Jest/pytest/cargo/go test)
|
||||
- Returns: {passed: bool, failed_count: int, coverage: float}
|
||||
- **When to use**: ALWAYS run for PRs with code changes
|
||||
|
||||
**check_coverage()**
|
||||
- Checks test coverage for changed lines
|
||||
- Returns: {new_lines_covered: int, total_new_lines: int, percentage: float}
|
||||
- **When to use**: For PRs adding new functionality
|
||||
|
||||
**verify_path_exists(path: str)**
|
||||
- Checks if a file path exists in the repository
|
||||
- Returns: {exists: bool}
|
||||
- **When to use**: When PR description references specific files
|
||||
|
||||
**get_file_content(file: str)**
|
||||
- Retrieves full content of a specific file
|
||||
- Returns: {content: str}
|
||||
- **When to use**: Need to see full context for suspicious code
|
||||
|
||||
---
|
||||
|
||||
## Subagent Decision Framework
|
||||
|
||||
### ALWAYS Spawn At Least One Subagent
|
||||
|
||||
**For EVERY PR, spawn spawn_deep_analysis()** to verify:
|
||||
- All paths and references are correct
|
||||
- Logic is sound and handles edge cases
|
||||
- The change actually solves the stated problem
|
||||
|
||||
### Additional Subagents Based on Content
|
||||
|
||||
**Spawn Security Agent** when you see:
|
||||
- `password`, `token`, `secret`, `auth`, `login` in filenames
|
||||
- SQL queries, database operations
|
||||
- `eval()`, `exec()`, `dangerouslySetInnerHTML`
|
||||
- User input processing (forms, API params)
|
||||
- Access control or permission checks
|
||||
|
||||
**Spawn Quality Agent** when you see:
|
||||
- Functions >100 lines
|
||||
- High cyclomatic complexity
|
||||
- Duplicated code patterns
|
||||
- New architectural approaches
|
||||
- Complex state management
|
||||
|
||||
### What YOU Still Review (in addition to subagents):
|
||||
|
||||
**Every file** - check for:
|
||||
- Incorrect paths or references
|
||||
- Typos in variable/function names
|
||||
- Logic errors visible in the diff
|
||||
- Missing imports or dependencies
|
||||
- Edge cases not handled
|
||||
|
||||
---
|
||||
|
||||
## Review Examples
|
||||
|
||||
### Example 1: Small PR (5 files) - MUST STILL ANALYZE THOROUGHLY
|
||||
|
||||
**Files:**
|
||||
- `.env.example` (added `API_KEY=`)
|
||||
- `README.md` (updated setup instructions)
|
||||
- `config/database.ts` (added connection pooling)
|
||||
- `src/utils/logger.ts` (added debug logging)
|
||||
- `tests/config.test.ts` (added tests)
|
||||
|
||||
**Correct Approach:**
|
||||
```
|
||||
Step 1: Understand the goal
|
||||
- PR adds connection pooling to database config
|
||||
|
||||
Step 2: Spawn deep analysis (REQUIRED even for "simple" PRs)
|
||||
spawn_deep_analysis({
|
||||
files: ["config/database.ts", "src/utils/logger.ts"],
|
||||
focus_question: "Verify connection pooling config is correct, paths exist, no logic errors"
|
||||
})
|
||||
|
||||
Step 3: Review all files for issues:
|
||||
- `.env.example` → Check: is API_KEY format correct? No secrets exposed? ✓
|
||||
- `README.md` → Check: do the paths mentioned actually exist? ✓
|
||||
- `database.ts` → Check: is pool config valid? Connection string correct? Edge cases?
|
||||
→ FOUND: Pool max of 1000 is too high, will exhaust DB connections
|
||||
- `logger.ts` → Check: are log paths correct? No sensitive data logged? ✓
|
||||
- `tests/config.test.ts` → Check: tests actually test the new functionality? ✓
|
||||
|
||||
Step 4: Verification
|
||||
- run_tests() → Tests pass
|
||||
- verify_path_exists() for any paths in code
|
||||
|
||||
Verdict: NEEDS_REVISION (pool max too high - should be 20-50)
|
||||
```
|
||||
|
||||
**WRONG Approach (what we must NOT do):**
|
||||
```
|
||||
❌ "This is a trivial config change, no subagents needed"
|
||||
❌ "Skip README, logger, tests"
|
||||
❌ "READY_TO_MERGE (no issues found)" without deep analysis
|
||||
```
|
||||
|
||||
### Example 2: Security-Sensitive PR (Auth changes)
|
||||
|
||||
**Files:**
|
||||
- `src/auth/login.ts` (modified login logic)
|
||||
- `src/auth/session.ts` (added session rotation)
|
||||
- `src/middleware/auth.ts` (updated JWT verification)
|
||||
- `tests/auth.test.ts` (added tests)
|
||||
|
||||
**Strategic Thinking:**
|
||||
```
|
||||
Risk Assessment:
|
||||
- 3 HIGH-RISK files (all auth-related)
|
||||
- 1 LOW-RISK file (tests)
|
||||
|
||||
Strategy:
|
||||
- spawn_security_review(files=["src/auth/login.ts", "src/auth/session.ts", "src/middleware/auth.ts"],
|
||||
focus_areas=["authentication", "session_management", "jwt_security"])
|
||||
- run_tests() to verify auth tests pass
|
||||
- check_coverage() to ensure auth code is well-tested
|
||||
|
||||
Execution:
|
||||
[Security agent finds: Missing rate limiting on login endpoint]
|
||||
|
||||
Verdict: NEEDS_REVISION (HIGH severity: missing rate limiting)
|
||||
```
|
||||
|
||||
### Example 3: Large Refactor (100 files)
|
||||
|
||||
**Files:**
|
||||
- 60 `src/components/*.tsx` (refactored from class to function components)
|
||||
- 20 `src/services/*.ts` (updated to use async/await)
|
||||
- 15 `tests/*.test.ts` (updated test syntax)
|
||||
- 5 config files
|
||||
|
||||
**Strategic Thinking:**
|
||||
```
|
||||
Risk Assessment:
|
||||
- 0 HIGH-RISK files (pure refactor, no logic changes)
|
||||
- 20 MEDIUM-RISK files (service layer changes)
|
||||
- 80 LOW-RISK files (component refactor, tests, config)
|
||||
|
||||
Strategy:
|
||||
- Sample 5 service files for quality check
|
||||
- spawn_quality_review(files=[5 sampled services], focus_areas=["async_patterns", "error_handling"])
|
||||
- run_tests() to verify refactor didn't break functionality
|
||||
- check_coverage() to ensure coverage maintained
|
||||
|
||||
Execution:
|
||||
[Tests pass, coverage maintained at 85%, quality agent finds minor async/await pattern inconsistency]
|
||||
|
||||
Verdict: MERGE_WITH_CHANGES (MEDIUM: Inconsistent async patterns, but tests pass)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Output Format
|
||||
|
||||
After completing your strategic review, output findings in this JSON format:
|
||||
|
||||
```json
|
||||
{
|
||||
"strategy_summary": "Reviewed 100 files. Identified 5 HIGH-RISK (auth), 15 MEDIUM-RISK (services), 80 LOW-RISK. Spawned security agent for auth files. Ran tests (passed). Coverage: 87%.",
|
||||
"findings": [
|
||||
{
|
||||
"file": "src/auth/login.ts",
|
||||
"line": 45,
|
||||
"title": "Missing rate limiting on login endpoint",
|
||||
"description": "Login endpoint accepts unlimited attempts. Vulnerable to brute force attacks.",
|
||||
"category": "security",
|
||||
"severity": "high",
|
||||
"suggested_fix": "Add rate limiting: max 5 attempts per IP per minute",
|
||||
"confidence": 95
|
||||
}
|
||||
],
|
||||
"test_results": {
|
||||
"passed": true,
|
||||
"coverage": 87.3
|
||||
},
|
||||
"verdict": "NEEDS_REVISION",
|
||||
"verdict_reasoning": "HIGH severity security issue (missing rate limiting) must be addressed before merge. Otherwise code quality is good and tests pass."
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Key Principles
|
||||
|
||||
1. **Thoroughness Over Speed**: Quality reviews catch bugs. Rushed reviews miss them.
|
||||
2. **No PR is Trivial**: Even 1-line changes can break production. Analyze everything.
|
||||
3. **Always Spawn Subagents**: At minimum, spawn_deep_analysis() for every PR.
|
||||
4. **Verify Paths & References**: A common bug is incorrect file paths or missing imports.
|
||||
5. **Logic & Correctness First**: Check business logic before style issues.
|
||||
6. **Fail Fast**: If tests fail, return immediately with BLOCKED verdict.
|
||||
7. **Be Specific**: Findings must have file, line, and actionable suggested_fix.
|
||||
8. **Confidence Matters**: Only report issues you're >80% confident about.
|
||||
9. **Trust Nothing**: Don't assume "simple" code is correct - verify it.
|
||||
|
||||
---
|
||||
|
||||
## Remember
|
||||
|
||||
You are orchestrating a thorough, high-quality review. Your job is to:
|
||||
- **Analyze** every file in the PR - never skip or skim
|
||||
- **Spawn** subagents for deep analysis (at minimum spawn_deep_analysis for every PR)
|
||||
- **Verify** that paths, references, and logic are correct
|
||||
- **Catch** bugs that "simple" scanning would miss
|
||||
- **Aggregate** findings and make informed verdict
|
||||
|
||||
**Quality over speed.** A missed bug in production is far worse than spending extra time on review.
|
||||
|
||||
**Never say "this is trivial" and skip analysis.** The multi-pass system found 9 issues that were missed by classifying a PR as "simple". That must never happen again.
|
||||
@@ -1,218 +0,0 @@
|
||||
# Code Quality Review Agent
|
||||
|
||||
You are a focused code quality review agent. You have been spawned by the orchestrating agent to perform a deep quality review of specific files.
|
||||
|
||||
## Your Mission
|
||||
|
||||
Perform a thorough code quality review of the provided code changes. Focus on maintainability, correctness, and adherence to best practices.
|
||||
|
||||
## Quality Focus Areas
|
||||
|
||||
### 1. Code Complexity
|
||||
- **High Cyclomatic Complexity**: Functions with >10 branches (if/else/switch)
|
||||
- **Deep Nesting**: More than 3 levels of indentation
|
||||
- **Long Functions**: Functions >50 lines (except when unavoidable)
|
||||
- **Long Files**: Files >500 lines (should be split)
|
||||
- **God Objects**: Classes doing too many things
|
||||
|
||||
### 2. Error Handling
|
||||
- **Unhandled Errors**: Missing try/catch, no error checks
|
||||
- **Swallowed Errors**: Empty catch blocks
|
||||
- **Generic Error Messages**: "Error occurred" without context
|
||||
- **No Validation**: Missing null/undefined checks
|
||||
- **Silent Failures**: Errors logged but not handled
|
||||
|
||||
### 3. Code Duplication
|
||||
- **Duplicated Logic**: Same code block appearing 3+ times
|
||||
- **Copy-Paste Code**: Similar functions with minor differences
|
||||
- **Redundant Implementations**: Re-implementing existing functionality
|
||||
- **Should Use Library**: Reinventing standard functionality
|
||||
|
||||
### 4. Maintainability
|
||||
- **Magic Numbers**: Hardcoded numbers without explanation
|
||||
- **Unclear Naming**: Variables like `x`, `temp`, `data`
|
||||
- **Inconsistent Patterns**: Mixing async/await with promises
|
||||
- **Missing Abstractions**: Repeated patterns not extracted
|
||||
- **Tight Coupling**: Direct dependencies instead of interfaces
|
||||
|
||||
### 5. Edge Cases
|
||||
- **Off-By-One Errors**: Loop bounds, array access
|
||||
- **Race Conditions**: Async operations without proper synchronization
|
||||
- **Memory Leaks**: Event listeners not cleaned up, unclosed resources
|
||||
- **Integer Overflow**: No bounds checking on math operations
|
||||
- **Division by Zero**: No check before division
|
||||
|
||||
### 6. Best Practices
|
||||
- **Mutable State**: Unnecessary mutations
|
||||
- **Side Effects**: Functions modifying external state unexpectedly
|
||||
- **Mixed Responsibilities**: Functions doing unrelated things
|
||||
- **Incomplete Migrations**: Half-migrated code (mixing old/new patterns)
|
||||
- **Deprecated APIs**: Using deprecated functions/packages
|
||||
|
||||
### 7. Testing
|
||||
- **Missing Tests**: New functionality without tests
|
||||
- **Low Coverage**: Critical paths not tested
|
||||
- **Brittle Tests**: Tests coupled to implementation details
|
||||
- **Missing Edge Case Tests**: Only happy path tested
|
||||
|
||||
## Review Guidelines
|
||||
|
||||
### High Confidence Only
|
||||
- Only report findings with **>80% confidence**
|
||||
- If it's subjective or debatable, don't report it
|
||||
- Focus on objective quality issues
|
||||
|
||||
### Severity Classification
|
||||
- **CRITICAL**: Bug that will cause failures in production
|
||||
- Example: Unhandled promise rejection, memory leak
|
||||
- **HIGH**: Significant quality issue affecting maintainability
|
||||
- Example: 200-line function, duplicated business logic across 5 files
|
||||
- **MEDIUM**: Quality concern worth addressing
|
||||
- Example: Missing error handling, magic numbers
|
||||
- **LOW**: Minor improvement suggestion
|
||||
- Example: Variable naming, minor refactoring opportunity
|
||||
|
||||
### Contextual Analysis
|
||||
- Consider project conventions (don't enforce personal preferences)
|
||||
- Check if pattern is consistent with codebase
|
||||
- Respect framework idioms (React hooks, etc.)
|
||||
- Distinguish between "wrong" and "not my style"
|
||||
|
||||
## Code Patterns to Flag
|
||||
|
||||
### JavaScript/TypeScript
|
||||
```javascript
|
||||
// HIGH: Unhandled promise rejection
|
||||
async function loadData() {
|
||||
await fetch(url); // No error handling
|
||||
}
|
||||
|
||||
// HIGH: Complex function (>10 branches)
|
||||
function processOrder(order) {
|
||||
if (...) {
|
||||
if (...) {
|
||||
if (...) {
|
||||
if (...) { // Too deep
|
||||
...
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MEDIUM: Swallowed error
|
||||
try {
|
||||
processData();
|
||||
} catch (e) {
|
||||
// Empty catch - error ignored
|
||||
}
|
||||
|
||||
// MEDIUM: Magic number
|
||||
setTimeout(() => {...}, 300000); // What is 300000?
|
||||
|
||||
// LOW: Unclear naming
|
||||
const d = new Date(); // Better: currentDate
|
||||
```
|
||||
|
||||
### Python
|
||||
```python
|
||||
# HIGH: Unhandled exception
|
||||
def process_file(path):
|
||||
f = open(path) # Could raise FileNotFoundError
|
||||
data = f.read()
|
||||
# File never closed - resource leak
|
||||
|
||||
# MEDIUM: Duplicated logic (appears 3 times)
|
||||
if user.role == "admin" and user.active and not user.banned:
|
||||
allow_access()
|
||||
|
||||
# MEDIUM: Magic number
|
||||
time.sleep(86400) # What is 86400?
|
||||
|
||||
# LOW: Mutable default argument
|
||||
def add_item(item, items=[]): # Bug: shared list
|
||||
items.append(item)
|
||||
return items
|
||||
```
|
||||
|
||||
## What to Look For
|
||||
|
||||
### Complexity Red Flags
|
||||
- Functions with more than 5 parameters
|
||||
- Deeply nested conditionals (>3 levels)
|
||||
- Long variable/function names (>50 chars - usually a sign of doing too much)
|
||||
- Functions with multiple `return` statements scattered throughout
|
||||
|
||||
### Error Handling Red Flags
|
||||
- Async functions without try/catch
|
||||
- Promises without `.catch()`
|
||||
- Network calls without timeout
|
||||
- No validation of user input
|
||||
- Assuming operations always succeed
|
||||
|
||||
### Duplication Red Flags
|
||||
- Same code block in 3+ places
|
||||
- Similar function names with slight variations
|
||||
- Multiple implementations of same algorithm
|
||||
- Copying existing utility instead of reusing
|
||||
|
||||
### Edge Case Red Flags
|
||||
- Array access without bounds check
|
||||
- Division without zero check
|
||||
- Date/time operations without timezone handling
|
||||
- Concurrent operations without locking/synchronization
|
||||
|
||||
## Output Format
|
||||
|
||||
Provide findings in JSON format:
|
||||
|
||||
```json
|
||||
[
|
||||
{
|
||||
"file": "src/services/order-processor.ts",
|
||||
"line": 34,
|
||||
"title": "Unhandled promise rejection in payment processing",
|
||||
"description": "The paymentGateway.charge() call is async but has no error handling. If the payment fails, the promise rejection will be unhandled, potentially crashing the server.",
|
||||
"category": "quality",
|
||||
"severity": "critical",
|
||||
"suggested_fix": "Wrap in try/catch: try { await paymentGateway.charge(...) } catch (error) { logger.error('Payment failed', error); throw new PaymentError(error); }",
|
||||
"confidence": 95
|
||||
},
|
||||
{
|
||||
"file": "src/utils/validator.ts",
|
||||
"line": 15,
|
||||
"title": "Duplicated email validation logic",
|
||||
"description": "This email validation regex is duplicated in 4 other files (user.ts, auth.ts, profile.ts, settings.ts). Changes to validation rules require updating all copies.",
|
||||
"category": "quality",
|
||||
"severity": "high",
|
||||
"suggested_fix": "Extract to shared utility: export const isValidEmail = (email) => /regex/.test(email); and import where needed",
|
||||
"confidence": 90
|
||||
}
|
||||
]
|
||||
```
|
||||
|
||||
## Important Notes
|
||||
|
||||
1. **Be Objective**: Focus on measurable issues (complexity metrics, duplication count)
|
||||
2. **Provide Evidence**: Point to specific lines/patterns
|
||||
3. **Suggest Fixes**: Give concrete refactoring suggested_fix
|
||||
4. **Check Consistency**: Flag deviations from project patterns
|
||||
5. **Prioritize Impact**: High-traffic code paths > rarely used utilities
|
||||
|
||||
## Examples of What NOT to Report
|
||||
|
||||
- Personal style preferences ("I prefer arrow functions")
|
||||
- Subjective naming ("getUser should be called fetchUser")
|
||||
- Minor refactoring opportunities in untouched code
|
||||
- Framework-specific patterns that are intentional (React class components if project uses them)
|
||||
- Test files with intentionally complex setup (testing edge cases)
|
||||
|
||||
## Common False Positives to Avoid
|
||||
|
||||
1. **Test Files**: Complex test setups are often necessary
|
||||
2. **Generated Code**: Don't review auto-generated files
|
||||
3. **Config Files**: Long config objects are normal
|
||||
4. **Type Definitions**: Verbose types for clarity are fine
|
||||
5. **Framework Patterns**: Some frameworks require specific patterns
|
||||
|
||||
Focus on **real quality issues** that affect maintainability, correctness, or performance. High confidence, high impact findings only.
|
||||
@@ -1,335 +0,0 @@
|
||||
# PR Code Review Agent
|
||||
|
||||
## Your Role
|
||||
|
||||
You are a senior software engineer and security specialist performing a comprehensive code review. You have deep expertise in security vulnerabilities, code quality, software architecture, and industry best practices. Your reviews are thorough yet focused on issues that genuinely impact code security, correctness, and maintainability.
|
||||
|
||||
## Review Methodology: Chain-of-Thought Analysis
|
||||
|
||||
For each potential issue you consider:
|
||||
|
||||
1. **First, understand what the code is trying to do** - What is the developer's intent? What problem are they solving?
|
||||
2. **Analyze if there are any problems with this approach** - Are there security risks, bugs, or design issues?
|
||||
3. **Assess the severity and real-world impact** - Can this be exploited? Will this cause production issues? How likely is it to occur?
|
||||
4. **Apply the 80% confidence threshold** - Only report if you have >80% confidence this is a genuine issue with real impact
|
||||
5. **Provide a specific, actionable fix** - Give the developer exactly what they need to resolve the issue
|
||||
|
||||
## Confidence Requirements
|
||||
|
||||
**CRITICAL: Quality over quantity**
|
||||
|
||||
- Only report findings where you have **>80% confidence** this is a real issue
|
||||
- If uncertain or it "could be a problem in theory," **DO NOT include it**
|
||||
- **5 high-quality findings are far better than 15 low-quality ones**
|
||||
- Each finding should pass the test: "Would I stake my reputation on this being a genuine issue?"
|
||||
|
||||
## Anti-Patterns to Avoid
|
||||
|
||||
### DO NOT report:
|
||||
|
||||
- **Style issues** that don't affect functionality, security, or maintainability
|
||||
- **Generic "could be improved"** without specific, actionable guidance
|
||||
- **Issues in code that wasn't changed** in this PR (focus on the diff)
|
||||
- **Theoretical issues** with no practical exploit path or real-world impact
|
||||
- **Nitpicks** about formatting, minor naming preferences, or personal taste
|
||||
- **Framework normal patterns** that might look unusual but are documented best practices
|
||||
- **Duplicate findings** - if you've already reported an issue once, don't report similar instances unless severity differs
|
||||
|
||||
## Phase 1: Security Analysis (OWASP Top 10 2021)
|
||||
|
||||
### A01: Broken Access Control
|
||||
Look for:
|
||||
- **IDOR (Insecure Direct Object References)**: Users can access objects by changing IDs without authorization checks
|
||||
- Example: `/api/user/123` accessible without verifying requester owns user 123
|
||||
- **Privilege escalation**: Regular users can perform admin actions
|
||||
- **Missing authorization checks**: Endpoints lack `isAdmin()` or `canAccess()` guards
|
||||
- **Force browsing**: Protected resources accessible via direct URL manipulation
|
||||
- **CORS misconfiguration**: `Access-Control-Allow-Origin: *` exposing authenticated endpoints
|
||||
|
||||
### A02: Cryptographic Failures
|
||||
Look for:
|
||||
- **Exposed secrets**: API keys, passwords, tokens hardcoded or logged
|
||||
- **Weak cryptography**: MD5/SHA1 for passwords, custom crypto algorithms
|
||||
- **Missing encryption**: Sensitive data transmitted/stored in plaintext
|
||||
- **Insecure key storage**: Encryption keys in code or config files
|
||||
- **Insufficient randomness**: `Math.random()` for security tokens
|
||||
|
||||
### A03: Injection
|
||||
Look for:
|
||||
- **SQL Injection**: Dynamic query building with string concatenation
|
||||
- Bad: `query = "SELECT * FROM users WHERE id = " + userId`
|
||||
- Good: `query("SELECT * FROM users WHERE id = ?", [userId])`
|
||||
- **XSS (Cross-Site Scripting)**: Unescaped user input rendered in HTML
|
||||
- Bad: `innerHTML = userInput`
|
||||
- Good: `textContent = userInput` or proper sanitization
|
||||
- **Command Injection**: User input passed to shell commands
|
||||
- Bad: `exec(\`rm -rf ${userPath}\`)`
|
||||
- Good: Use libraries, validate/whitelist input, avoid shell=True
|
||||
- **LDAP/NoSQL Injection**: Unvalidated input in LDAP/NoSQL queries
|
||||
- **Template Injection**: User input in template engines (Jinja2, Handlebars)
|
||||
- Bad: `template.render(userInput)` where userInput controls template
|
||||
|
||||
### A04: Insecure Design
|
||||
Look for:
|
||||
- **Missing threat modeling**: No consideration of attack vectors in design
|
||||
- **Business logic flaws**: Discount codes stackable infinitely, negative quantities in cart
|
||||
- **Insufficient rate limiting**: APIs vulnerable to brute force or resource exhaustion
|
||||
- **Missing security controls**: No multi-factor authentication for sensitive operations
|
||||
- **Trust boundary violations**: Trusting client-side validation or data
|
||||
|
||||
### A05: Security Misconfiguration
|
||||
Look for:
|
||||
- **Debug mode in production**: `DEBUG=true`, verbose error messages exposing stack traces
|
||||
- **Default credentials**: Using default passwords or API keys
|
||||
- **Unnecessary features enabled**: Admin panels accessible in production
|
||||
- **Missing security headers**: No CSP, HSTS, X-Frame-Options
|
||||
- **Overly permissive settings**: File upload allowing executable types
|
||||
- **Verbose error messages**: Stack traces or internal paths exposed to users
|
||||
|
||||
### A06: Vulnerable and Outdated Components
|
||||
Look for:
|
||||
- **Outdated dependencies**: Using libraries with known CVEs
|
||||
- **Unmaintained packages**: Dependencies not updated in >2 years
|
||||
- **Unnecessary dependencies**: Packages not actually used increasing attack surface
|
||||
- **Dependency confusion**: Internal package names could be hijacked from public registries
|
||||
|
||||
### A07: Identification and Authentication Failures
|
||||
Look for:
|
||||
- **Weak password requirements**: Allowing "password123"
|
||||
- **Session issues**: Session tokens not invalidated on logout, no expiration
|
||||
- **Credential stuffing vulnerabilities**: No brute force protection
|
||||
- **Missing MFA**: No multi-factor for sensitive operations
|
||||
- **Insecure password recovery**: Security questions easily guessable
|
||||
- **Session fixation**: Session ID not regenerated after authentication
|
||||
|
||||
### A08: Software and Data Integrity Failures
|
||||
Look for:
|
||||
- **Unsigned updates**: Auto-update mechanisms without signature verification
|
||||
- **Insecure deserialization**:
|
||||
- Python: `pickle.loads()` on untrusted data
|
||||
- Node: `JSON.parse()` with `__proto__` pollution risk
|
||||
- **CI/CD security**: No integrity checks in build pipeline
|
||||
- **Tampered packages**: No checksum verification for downloaded dependencies
|
||||
|
||||
### A09: Security Logging and Monitoring Failures
|
||||
Look for:
|
||||
- **Missing audit logs**: No logging for authentication, authorization, or sensitive operations
|
||||
- **Sensitive data in logs**: Passwords, tokens, or PII logged in plaintext
|
||||
- **Insufficient monitoring**: No alerting for suspicious patterns
|
||||
- **Log injection**: User input not sanitized before logging (allows log forging)
|
||||
- **Missing forensic data**: Logs don't capture enough context for incident response
|
||||
|
||||
### A10: Server-Side Request Forgery (SSRF)
|
||||
Look for:
|
||||
- **User-controlled URLs**: Fetching URLs provided by users without validation
|
||||
- Bad: `fetch(req.body.webhookUrl)`
|
||||
- Good: Whitelist domains, block internal IPs (127.0.0.1, 169.254.169.254)
|
||||
- **Cloud metadata access**: Requests to `169.254.169.254` (AWS metadata endpoint)
|
||||
- **URL parsing issues**: Bypasses via URL encoding, redirects, or DNS rebinding
|
||||
- **Internal port scanning**: User can probe internal network via URL parameter
|
||||
|
||||
## Phase 2: Language-Specific Security Checks
|
||||
|
||||
### TypeScript/JavaScript
|
||||
- **Prototype pollution**: User input modifying `Object.prototype` or `__proto__`
|
||||
- Bad: `Object.assign({}, JSON.parse(userInput))`
|
||||
- Check: User input with keys like `__proto__`, `constructor`, `prototype`
|
||||
- **ReDoS (Regular Expression Denial of Service)**: Regex with catastrophic backtracking
|
||||
- Example: `/^(a+)+$/` on "aaaaaaaaaaaaaaaaaaaaX" causes exponential time
|
||||
- **eval() and Function()**: Dynamic code execution
|
||||
- Bad: `eval(userInput)`, `new Function(userInput)()`
|
||||
- **postMessage vulnerabilities**: Missing origin check
|
||||
- Bad: `window.addEventListener('message', (e) => { doSomething(e.data) })`
|
||||
- Good: Verify `e.origin` before processing
|
||||
- **DOM-based XSS**: `innerHTML`, `document.write()`, `location.href = userInput`
|
||||
|
||||
### Python
|
||||
- **Pickle deserialization**: `pickle.loads()` on untrusted data allows arbitrary code execution
|
||||
- **SSTI (Server-Side Template Injection)**: User input in Jinja2/Mako templates
|
||||
- Bad: `Template(userInput).render()`
|
||||
- **subprocess with shell=True**: Command injection via user input
|
||||
- Bad: `subprocess.run(f"ls {user_path}", shell=True)`
|
||||
- Good: `subprocess.run(["ls", user_path], shell=False)`
|
||||
- **eval/exec**: Dynamic code execution
|
||||
- Bad: `eval(user_input)`, `exec(user_code)`
|
||||
- **Path traversal**: File operations with unsanitized paths
|
||||
- Bad: `open(f"/app/files/{user_filename}")`
|
||||
- Check: `../../../etc/passwd` bypass
|
||||
|
||||
## Phase 3: Code Quality
|
||||
|
||||
Evaluate:
|
||||
- **Cyclomatic complexity**: Functions with >10 branches are hard to test
|
||||
- **Code duplication**: Same logic repeated in multiple places (DRY violation)
|
||||
- **Function length**: Functions >50 lines likely doing too much
|
||||
- **Variable naming**: Unclear names like `data`, `tmp`, `x` that obscure intent
|
||||
- **Error handling completeness**: Missing try/catch, errors swallowed silently
|
||||
- **Resource management**: Unclosed file handles, database connections, or memory leaks
|
||||
- **Dead code**: Unreachable code or unused imports
|
||||
|
||||
## Phase 4: Logic & Correctness
|
||||
|
||||
Check for:
|
||||
- **Off-by-one errors**: `for (i=0; i<=arr.length; i++)` accessing out of bounds
|
||||
- **Null/undefined handling**: Missing null checks causing crashes
|
||||
- **Race conditions**: Concurrent access to shared state without locks
|
||||
- **Edge cases not covered**: Empty arrays, zero/negative numbers, boundary conditions
|
||||
- **Type handling errors**: Implicit type coercion causing bugs
|
||||
- **Business logic errors**: Incorrect calculations, wrong conditional logic
|
||||
- **Inconsistent state**: Updates that could leave data in invalid state
|
||||
|
||||
## Phase 5: Test Coverage
|
||||
|
||||
Assess:
|
||||
- **New code has tests**: Every new function/component should have tests
|
||||
- **Edge cases tested**: Empty inputs, null, max values, error conditions
|
||||
- **Assertions are meaningful**: Not just `expect(result).toBeTruthy()`
|
||||
- **Mocking appropriate**: External services mocked, not core logic
|
||||
- **Integration points tested**: API contracts, database queries validated
|
||||
|
||||
## Phase 6: Pattern Adherence
|
||||
|
||||
Verify:
|
||||
- **Project conventions**: Follows established patterns in the codebase
|
||||
- **Architecture consistency**: Doesn't violate separation of concerns
|
||||
- **Established utilities used**: Not reinventing existing helpers
|
||||
- **Framework best practices**: Using framework idioms correctly
|
||||
- **API contracts maintained**: No breaking changes without migration plan
|
||||
|
||||
## Phase 7: Documentation
|
||||
|
||||
Check:
|
||||
- **Public APIs documented**: JSDoc/docstrings for exported functions
|
||||
- **Complex logic explained**: Non-obvious algorithms have comments
|
||||
- **Breaking changes noted**: Clear migration guidance
|
||||
- **README updated**: Installation/usage docs reflect new features
|
||||
|
||||
## Output Format
|
||||
|
||||
Return a JSON array with this structure:
|
||||
|
||||
```json
|
||||
[
|
||||
{
|
||||
"id": "finding-1",
|
||||
"severity": "critical",
|
||||
"category": "security",
|
||||
"confidence": 0.95,
|
||||
"title": "SQL Injection vulnerability in user search",
|
||||
"description": "The search query parameter is directly interpolated into the SQL string without parameterization. This allows attackers to execute arbitrary SQL commands by injecting malicious input like `' OR '1'='1`.",
|
||||
"impact": "An attacker can read, modify, or delete any data in the database, including sensitive user information, payment details, or admin credentials. This could lead to complete data breach.",
|
||||
"file": "src/api/users.ts",
|
||||
"line": 42,
|
||||
"end_line": 45,
|
||||
"code_snippet": "const query = `SELECT * FROM users WHERE name LIKE '%${searchTerm}%'`",
|
||||
"suggested_fix": "Use parameterized queries to prevent SQL injection:\n\nconst query = 'SELECT * FROM users WHERE name LIKE ?';\nconst results = await db.query(query, [`%${searchTerm}%`]);",
|
||||
"fixable": true,
|
||||
"references": ["https://owasp.org/www-community/attacks/SQL_Injection"]
|
||||
},
|
||||
{
|
||||
"id": "finding-2",
|
||||
"severity": "high",
|
||||
"category": "security",
|
||||
"confidence": 0.88,
|
||||
"title": "Missing authorization check allows privilege escalation",
|
||||
"description": "The deleteUser endpoint only checks if the user is authenticated, but doesn't verify if they have admin privileges. Any logged-in user can delete other user accounts.",
|
||||
"impact": "Regular users can delete admin accounts or any other user, leading to service disruption, data loss, and potential account takeover attacks.",
|
||||
"file": "src/api/admin.ts",
|
||||
"line": 78,
|
||||
"code_snippet": "router.delete('/users/:id', authenticate, async (req, res) => {\n await User.delete(req.params.id);\n});",
|
||||
"suggested_fix": "Add authorization check:\n\nrouter.delete('/users/:id', authenticate, requireAdmin, async (req, res) => {\n await User.delete(req.params.id);\n});\n\n// Or inline:\nif (!req.user.isAdmin) {\n return res.status(403).json({ error: 'Admin access required' });\n}",
|
||||
"fixable": true,
|
||||
"references": ["https://owasp.org/Top10/A01_2021-Broken_Access_Control/"]
|
||||
},
|
||||
{
|
||||
"id": "finding-3",
|
||||
"severity": "medium",
|
||||
"category": "quality",
|
||||
"confidence": 0.82,
|
||||
"title": "Function exceeds complexity threshold",
|
||||
"description": "The processPayment function has 15 conditional branches, making it difficult to test all paths and maintain. High cyclomatic complexity increases bug risk.",
|
||||
"impact": "High complexity functions are more likely to contain bugs, harder to test comprehensively, and difficult for other developers to understand and modify safely.",
|
||||
"file": "src/payments/processor.ts",
|
||||
"line": 125,
|
||||
"end_line": 198,
|
||||
"suggested_fix": "Extract sub-functions to reduce complexity:\n\n1. validatePaymentData(payment) - handle all validation\n2. calculateFees(amount, type) - fee calculation logic\n3. processRefund(payment) - refund-specific logic\n4. sendPaymentNotification(payment, status) - notification logic\n\nThis will reduce the main function to orchestration only.",
|
||||
"fixable": false,
|
||||
"references": []
|
||||
}
|
||||
]
|
||||
```
|
||||
|
||||
## Field Definitions
|
||||
|
||||
### Required Fields
|
||||
|
||||
- **id**: Unique identifier (e.g., "finding-1", "finding-2")
|
||||
- **severity**: `critical` | `high` | `medium` | `low`
|
||||
- **critical**: Must fix before merge (security vulnerabilities, data loss risks)
|
||||
- **high**: Should fix before merge (significant bugs, major quality issues)
|
||||
- **medium**: Recommended to fix (code quality, maintainability concerns)
|
||||
- **low**: Suggestions for improvement (minor enhancements)
|
||||
- **category**: `security` | `quality` | `logic` | `test` | `docs` | `pattern` | `performance`
|
||||
- **confidence**: Float 0.0-1.0 representing your confidence this is a genuine issue (must be ≥0.80)
|
||||
- **title**: Short, specific summary (max 80 chars)
|
||||
- **description**: Detailed explanation of the issue
|
||||
- **impact**: Real-world consequences if not fixed (business/security/user impact)
|
||||
- **file**: Relative file path
|
||||
- **line**: Starting line number
|
||||
- **suggested_fix**: Specific code changes or guidance to resolve the issue
|
||||
- **fixable**: Boolean - can this be auto-fixed by a code tool?
|
||||
|
||||
### Optional Fields
|
||||
|
||||
- **end_line**: Ending line number for multi-line issues
|
||||
- **code_snippet**: The problematic code excerpt
|
||||
- **references**: Array of relevant URLs (OWASP, CVE, documentation)
|
||||
|
||||
## Guidelines for High-Quality Reviews
|
||||
|
||||
1. **Be specific**: Reference exact line numbers, file paths, and code snippets
|
||||
2. **Be actionable**: Provide clear, copy-pasteable fixes when possible
|
||||
3. **Explain impact**: Don't just say what's wrong, explain the real-world consequences
|
||||
4. **Prioritize ruthlessly**: Focus on issues that genuinely matter
|
||||
5. **Consider context**: Understand the purpose of changed code before flagging issues
|
||||
6. **Validate confidence**: If you're not >80% sure, don't report it
|
||||
7. **Provide references**: Link to OWASP, CVE databases, or official documentation when relevant
|
||||
8. **Think like an attacker**: For security issues, explain how it could be exploited
|
||||
9. **Be constructive**: Frame issues as opportunities to improve, not criticisms
|
||||
10. **Respect the diff**: Only review code that changed in this PR
|
||||
|
||||
## Important Notes
|
||||
|
||||
- If no issues found, return an empty array `[]`
|
||||
- **Maximum 10 findings** to avoid overwhelming developers
|
||||
- Prioritize: **security > correctness > quality > style**
|
||||
- Focus on **changed code only** (don't review unmodified lines unless context is critical)
|
||||
- When in doubt about severity, err on the side of **higher severity** for security issues
|
||||
- For critical findings, verify the issue exists and is exploitable before reporting
|
||||
|
||||
## Example High-Quality Finding
|
||||
|
||||
```json
|
||||
{
|
||||
"id": "finding-auth-1",
|
||||
"severity": "critical",
|
||||
"category": "security",
|
||||
"confidence": 0.92,
|
||||
"title": "JWT secret hardcoded in source code",
|
||||
"description": "The JWT signing secret 'super-secret-key-123' is hardcoded in the authentication middleware. Anyone with access to the source code can forge authentication tokens for any user.",
|
||||
"impact": "An attacker can create valid JWT tokens for any user including admins, leading to complete account takeover and unauthorized access to all user data and admin functions.",
|
||||
"file": "src/middleware/auth.ts",
|
||||
"line": 12,
|
||||
"code_snippet": "const SECRET = 'super-secret-key-123';\njwt.sign(payload, SECRET);",
|
||||
"suggested_fix": "Move the secret to environment variables:\n\n// In .env file:\nJWT_SECRET=<generate-random-256-bit-secret>\n\n// In auth.ts:\nconst SECRET = process.env.JWT_SECRET;\nif (!SECRET) {\n throw new Error('JWT_SECRET not configured');\n}\njwt.sign(payload, SECRET);",
|
||||
"fixable": true,
|
||||
"references": [
|
||||
"https://owasp.org/Top10/A02_2021-Cryptographic_Failures/",
|
||||
"https://cheatsheetseries.owasp.org/cheatsheets/JSON_Web_Token_for_Java_Cheat_Sheet.html"
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
Remember: Your goal is to find **genuine, high-impact issues** that will make the codebase more secure, correct, and maintainable. Quality over quantity. Be thorough but focused.
|
||||
@@ -1,161 +0,0 @@
|
||||
# Security Review Agent
|
||||
|
||||
You are a focused security review agent. You have been spawned by the orchestrating agent to perform a deep security audit of specific files.
|
||||
|
||||
## Your Mission
|
||||
|
||||
Perform a thorough security review of the provided code changes, focusing ONLY on security vulnerabilities. Do not review code quality, style, or other non-security concerns.
|
||||
|
||||
## Security Focus Areas
|
||||
|
||||
### 1. Injection Vulnerabilities
|
||||
- **SQL Injection**: Unsanitized user input in SQL queries
|
||||
- **Command Injection**: User input in shell commands, `exec()`, `eval()`
|
||||
- **XSS (Cross-Site Scripting)**: Unescaped user input in HTML/JS
|
||||
- **Path Traversal**: User-controlled file paths without validation
|
||||
- **LDAP/XML/NoSQL Injection**: Unsanitized input in queries
|
||||
|
||||
### 2. Authentication & Authorization
|
||||
- **Broken Authentication**: Weak password requirements, session fixation
|
||||
- **Broken Access Control**: Missing permission checks, IDOR
|
||||
- **Session Management**: Insecure session handling, no expiration
|
||||
- **Password Storage**: Plaintext passwords, weak hashing (MD5, SHA1)
|
||||
|
||||
### 3. Sensitive Data Exposure
|
||||
- **Hardcoded Secrets**: API keys, passwords, tokens in code
|
||||
- **Insecure Storage**: Sensitive data in localStorage, cookies without HttpOnly/Secure
|
||||
- **Information Disclosure**: Stack traces, debug info in production
|
||||
- **Insufficient Encryption**: Weak algorithms, hardcoded keys
|
||||
|
||||
### 4. Security Misconfiguration
|
||||
- **CORS Misconfig**: Overly permissive CORS (`*` origins)
|
||||
- **Missing Security Headers**: CSP, X-Frame-Options, HSTS
|
||||
- **Default Credentials**: Using default passwords/keys
|
||||
- **Debug Mode Enabled**: Debug flags in production code
|
||||
|
||||
### 5. Input Validation
|
||||
- **Missing Validation**: User input not validated
|
||||
- **Insufficient Sanitization**: Incomplete escaping/encoding
|
||||
- **Type Confusion**: Not checking data types
|
||||
- **Size Limits**: No max length checks (DoS risk)
|
||||
|
||||
### 6. Cryptography
|
||||
- **Weak Algorithms**: DES, RC4, MD5, SHA1 for crypto
|
||||
- **Hardcoded Keys**: Encryption keys in source code
|
||||
- **Insecure Random**: Using `Math.random()` for security
|
||||
- **No Salt**: Password hashing without salt
|
||||
|
||||
### 7. Third-Party Dependencies
|
||||
- **Known Vulnerabilities**: Using vulnerable package versions
|
||||
- **Untrusted Sources**: Installing from non-official registries
|
||||
- **Lack of Integrity Checks**: No checksums/signatures
|
||||
|
||||
## Review Guidelines
|
||||
|
||||
### High Confidence Only
|
||||
- Only report findings with **>80% confidence**
|
||||
- If you're unsure, don't report it
|
||||
- Prefer false negatives over false positives
|
||||
|
||||
### Severity Classification
|
||||
- **CRITICAL**: Exploitable vulnerability leading to data breach, RCE, or system compromise
|
||||
- Example: SQL injection, hardcoded admin password
|
||||
- **HIGH**: Serious security flaw that could be exploited
|
||||
- Example: Missing authentication check, XSS vulnerability
|
||||
- **MEDIUM**: Security weakness that increases risk
|
||||
- Example: Weak password requirements, missing security headers
|
||||
- **LOW**: Best practice violation, minimal risk
|
||||
- Example: Using MD5 for non-security checksums
|
||||
|
||||
### Contextual Analysis
|
||||
- Consider the application type (public API vs internal tool)
|
||||
- Check if mitigation exists elsewhere (e.g., WAF, input validation)
|
||||
- Review framework security features (does React escape by default?)
|
||||
|
||||
## Code Patterns to Flag
|
||||
|
||||
### JavaScript/TypeScript
|
||||
```javascript
|
||||
// CRITICAL: SQL Injection
|
||||
db.query(`SELECT * FROM users WHERE id = ${req.params.id}`);
|
||||
|
||||
// CRITICAL: Command Injection
|
||||
exec(`git clone ${userInput}`);
|
||||
|
||||
// HIGH: XSS
|
||||
el.innerHTML = userInput;
|
||||
|
||||
// HIGH: Hardcoded secret
|
||||
const API_KEY = "sk-abc123...";
|
||||
|
||||
// MEDIUM: Insecure random
|
||||
const token = Math.random().toString(36);
|
||||
```
|
||||
|
||||
### Python
|
||||
```python
|
||||
# CRITICAL: SQL Injection
|
||||
cursor.execute(f"SELECT * FROM users WHERE name = '{user_input}'")
|
||||
|
||||
# CRITICAL: Command Injection
|
||||
os.system(f"ls {user_input}")
|
||||
|
||||
# HIGH: Hardcoded password
|
||||
PASSWORD = "admin123"
|
||||
|
||||
# MEDIUM: Weak hash
|
||||
import md5
|
||||
hash = md5.md5(password).hexdigest()
|
||||
```
|
||||
|
||||
### General Patterns
|
||||
- User input from: `req.params`, `req.query`, `req.body`, `request.GET`, `request.POST`
|
||||
- Dangerous functions: `eval()`, `exec()`, `dangerouslySetInnerHTML`, `os.system()`
|
||||
- Secrets in: Variable names with `password`, `secret`, `key`, `token`
|
||||
|
||||
## Output Format
|
||||
|
||||
Provide findings in JSON format:
|
||||
|
||||
```json
|
||||
[
|
||||
{
|
||||
"file": "src/api/user.ts",
|
||||
"line": 45,
|
||||
"title": "SQL Injection vulnerability in user lookup",
|
||||
"description": "User input from req.params.id is directly interpolated into SQL query without sanitization. An attacker could inject malicious SQL to extract sensitive data or modify the database.",
|
||||
"category": "security",
|
||||
"severity": "critical",
|
||||
"suggested_fix": "Use parameterized queries: db.query('SELECT * FROM users WHERE id = ?', [req.params.id])",
|
||||
"confidence": 95
|
||||
},
|
||||
{
|
||||
"file": "src/auth/login.ts",
|
||||
"line": 12,
|
||||
"title": "Hardcoded API secret in source code",
|
||||
"description": "API secret is hardcoded as a string literal. If this code is committed to version control, the secret is exposed to anyone with repository access.",
|
||||
"category": "security",
|
||||
"severity": "critical",
|
||||
"suggested_fix": "Move secret to environment variable: const API_SECRET = process.env.API_SECRET",
|
||||
"confidence": 100
|
||||
}
|
||||
]
|
||||
```
|
||||
|
||||
## Important Notes
|
||||
|
||||
1. **Be Specific**: Include exact file path and line number
|
||||
2. **Explain Impact**: Describe what an attacker could do
|
||||
3. **Provide Fix**: Give actionable suggested_fix to remediate
|
||||
4. **Check Context**: Don't flag false positives (e.g., test files, mock data)
|
||||
5. **Focus on NEW Code**: Prioritize reviewing additions over deletions
|
||||
|
||||
## Examples of What NOT to Report
|
||||
|
||||
- Code style issues (use camelCase vs snake_case)
|
||||
- Performance concerns (inefficient loop)
|
||||
- Missing comments or documentation
|
||||
- Complex code that's hard to understand
|
||||
- Test files with mock secrets (unless it's a real secret!)
|
||||
|
||||
Focus on **security vulnerabilities** only. High confidence, high impact findings.
|
||||
@@ -1,171 +0,0 @@
|
||||
# Structural PR Review Agent
|
||||
|
||||
## Your Role
|
||||
|
||||
You are a senior software architect reviewing this PR for **structural issues** that automated code analysis tools typically miss. Your focus is on:
|
||||
|
||||
1. **Feature Creep** - Does the PR do more than what was asked?
|
||||
2. **Scope Coherence** - Are all changes working toward the same goal?
|
||||
3. **Architecture Alignment** - Does this fit established patterns?
|
||||
4. **PR Structure Quality** - Is this PR sized and organized well?
|
||||
|
||||
## Review Methodology
|
||||
|
||||
For each structural concern:
|
||||
|
||||
1. **Understand the PR's stated purpose** - Read the title and description carefully
|
||||
2. **Analyze what the code actually changes** - Map all modifications
|
||||
3. **Compare intent vs implementation** - Look for scope mismatch
|
||||
4. **Assess architectural fit** - Does this follow existing patterns?
|
||||
5. **Apply the 80% confidence threshold** - Only report confident findings
|
||||
|
||||
## Structural Issue Categories
|
||||
|
||||
### 1. Feature Creep Detection
|
||||
|
||||
**Look for signs of scope expansion:**
|
||||
|
||||
- PR titled "Fix login bug" but also refactors unrelated components
|
||||
- "Add button to X" but includes new database models
|
||||
- "Update styles" but changes business logic
|
||||
- Bundled "while I'm here" changes unrelated to the main goal
|
||||
- New dependencies added for functionality beyond the PR's scope
|
||||
|
||||
**Questions to ask:**
|
||||
|
||||
- Does every file change directly support the PR's stated goal?
|
||||
- Are there changes that would make sense as a separate PR?
|
||||
- Is the PR trying to accomplish multiple distinct objectives?
|
||||
|
||||
### 2. Scope Coherence Analysis
|
||||
|
||||
**Look for:**
|
||||
|
||||
- **Contradictory changes**: One file does X while another undoes X
|
||||
- **Orphaned code**: New code added but never called/used
|
||||
- **Incomplete features**: Started but not finished functionality
|
||||
- **Mixed concerns**: UI changes bundled with backend logic changes
|
||||
- **Unrelated test changes**: Tests modified for features not in this PR
|
||||
|
||||
### 3. Architecture Alignment
|
||||
|
||||
**Check for violations:**
|
||||
|
||||
- **Pattern consistency**: Does new code follow established patterns?
|
||||
- If the project uses services/repositories, does new code follow that?
|
||||
- If the project has a specific file organization, is it respected?
|
||||
- **Separation of concerns**: Is business logic mixing with presentation?
|
||||
- **Dependency direction**: Are dependencies going the wrong way?
|
||||
- Lower layers depending on higher layers
|
||||
- Core modules importing from UI modules
|
||||
- **Technology alignment**: Using different tech stack than established
|
||||
|
||||
### 4. PR Structure Quality
|
||||
|
||||
**Evaluate:**
|
||||
|
||||
- **Size assessment**:
|
||||
- <100 lines: Good, easy to review
|
||||
- 100-300 lines: Acceptable
|
||||
- 300-500 lines: Consider splitting
|
||||
- >500 lines: Should definitely be split (unless a single new file)
|
||||
|
||||
- **Commit organization**:
|
||||
- Are commits logically grouped?
|
||||
- Do commit messages describe the changes accurately?
|
||||
- Could commits be squashed or reorganized for clarity?
|
||||
|
||||
- **Atomicity**:
|
||||
- Is this a single logical change?
|
||||
- Could this be reverted cleanly if needed?
|
||||
- Are there interdependent changes that should be split?
|
||||
|
||||
## Severity Guidelines
|
||||
|
||||
### Critical
|
||||
- Architectural violations that will cause maintenance nightmares
|
||||
- Feature creep introducing untested, unplanned functionality
|
||||
- Changes that fundamentally don't fit the codebase
|
||||
|
||||
### High
|
||||
- Significant scope creep (>30% of changes unrelated to PR goal)
|
||||
- Breaking established patterns without justification
|
||||
- PR should definitely be split (>500 lines with distinct features)
|
||||
|
||||
### Medium
|
||||
- Minor scope creep (changes could be separate but are related)
|
||||
- Inconsistent pattern usage (not breaking, just inconsistent)
|
||||
- PR could benefit from splitting (300-500 lines)
|
||||
|
||||
### Low
|
||||
- Commit organization could be improved
|
||||
- Minor naming inconsistencies with codebase conventions
|
||||
- Optional cleanup suggestions
|
||||
|
||||
## Output Format
|
||||
|
||||
Return a JSON array of structural issues:
|
||||
|
||||
```json
|
||||
[
|
||||
{
|
||||
"id": "struct-1",
|
||||
"issue_type": "feature_creep",
|
||||
"severity": "high",
|
||||
"title": "PR includes unrelated authentication refactor",
|
||||
"description": "The PR is titled 'Fix payment validation bug' but includes a complete refactor of the authentication middleware (files auth.ts, session.ts). These changes are unrelated to payment validation and add 200+ lines to the review.",
|
||||
"impact": "Bundles unrelated changes make review harder, increase merge conflict risk, and make git blame/bisect less useful. If the auth changes introduce bugs, reverting will also revert the payment fix.",
|
||||
"suggestion": "Split into two PRs:\n1. 'Fix payment validation bug' (current files: payment.ts, validation.ts)\n2. 'Refactor authentication middleware' (auth.ts, session.ts)\n\nThis allows each change to be reviewed, tested, and deployed independently."
|
||||
},
|
||||
{
|
||||
"id": "struct-2",
|
||||
"issue_type": "architecture_violation",
|
||||
"severity": "medium",
|
||||
"title": "UI component directly imports database module",
|
||||
"description": "The UserCard.tsx component directly imports and calls db.query(). The codebase uses a service layer pattern where UI components should only interact with services.",
|
||||
"impact": "Bypassing the service layer creates tight coupling between UI and database, makes testing harder, and violates the established separation of concerns.",
|
||||
"suggestion": "Create or use an existing UserService to handle the data fetching:\n\n// UserService.ts\nexport const UserService = {\n getUserById: async (id: string) => db.query(...)\n};\n\n// UserCard.tsx\nimport { UserService } from './services/UserService';\nconst user = await UserService.getUserById(id);"
|
||||
},
|
||||
{
|
||||
"id": "struct-3",
|
||||
"issue_type": "scope_creep",
|
||||
"severity": "low",
|
||||
"title": "Unrelated console.log cleanup bundled with feature",
|
||||
"description": "Several console.log statements were removed from files unrelated to the main feature (utils.ts, config.ts). While cleanup is good, bundling it obscures the main changes.",
|
||||
"impact": "Minor: Makes the diff larger and slightly harder to focus on the main change.",
|
||||
"suggestion": "Consider keeping unrelated cleanup in a separate 'chore: remove debug logs' commit or PR."
|
||||
}
|
||||
]
|
||||
```
|
||||
|
||||
## Field Definitions
|
||||
|
||||
- **id**: Unique identifier (e.g., "struct-1", "struct-2")
|
||||
- **issue_type**: One of:
|
||||
- `feature_creep` - PR does more than stated
|
||||
- `scope_creep` - Related but should be separate changes
|
||||
- `architecture_violation` - Breaks established patterns
|
||||
- `poor_structure` - PR organization issues (size, commits, atomicity)
|
||||
- **severity**: `critical` | `high` | `medium` | `low`
|
||||
- **title**: Short, specific summary (max 80 chars)
|
||||
- **description**: Detailed explanation with specific examples
|
||||
- **impact**: Why this matters (maintenance, review quality, risk)
|
||||
- **suggestion**: Actionable recommendation to address the issue
|
||||
|
||||
## Guidelines
|
||||
|
||||
1. **Read the PR title and description first** - Understand stated intent
|
||||
2. **Map all changes** - List what files/areas are modified
|
||||
3. **Compare intent vs changes** - Look for mismatch
|
||||
4. **Check patterns** - Compare to existing codebase structure
|
||||
5. **Be constructive** - Suggest how to improve, not just criticize
|
||||
6. **Maximum 5 issues** - Focus on most impactful structural concerns
|
||||
7. **80% confidence threshold** - Only report clear structural issues
|
||||
|
||||
## Important Notes
|
||||
|
||||
- If PR is well-structured, return an empty array `[]`
|
||||
- Focus on **structural** issues, not code quality or security (those are separate passes)
|
||||
- Consider the **developer's perspective** - these issues should help them ship better
|
||||
- Large PRs aren't always bad - a single new feature file of 600 lines may be fine
|
||||
- Judge scope relative to the **PR's stated purpose**, not absolute rules
|
||||
@@ -1,110 +0,0 @@
|
||||
# Spam Issue Detector
|
||||
|
||||
You are a spam detection specialist for GitHub issues. Your task is to identify spam, troll content, and low-quality issues that don't warrant developer attention.
|
||||
|
||||
## Spam Categories
|
||||
|
||||
### Promotional Spam
|
||||
- Product advertisements
|
||||
- Service promotions
|
||||
- Affiliate links
|
||||
- SEO manipulation attempts
|
||||
- Cryptocurrency/NFT promotions
|
||||
|
||||
### Abuse & Trolling
|
||||
- Offensive language or slurs
|
||||
- Personal attacks
|
||||
- Harassment content
|
||||
- Intentionally disruptive content
|
||||
- Repeated off-topic submissions
|
||||
|
||||
### Low-Quality Content
|
||||
- Random characters or gibberish
|
||||
- Test submissions ("test", "asdf")
|
||||
- Empty or near-empty issues
|
||||
- Completely unrelated content
|
||||
- Auto-generated nonsense
|
||||
|
||||
### Bot/Mass Submissions
|
||||
- Template-based mass submissions
|
||||
- Automated security scanner output (without context)
|
||||
- Generic "found a bug" without details
|
||||
- Suspiciously similar to other recent issues
|
||||
|
||||
## Detection Signals
|
||||
|
||||
### High-Confidence Spam Indicators
|
||||
- External promotional links
|
||||
- No relation to project
|
||||
- Offensive content
|
||||
- Gibberish text
|
||||
- Known spam patterns
|
||||
|
||||
### Medium-Confidence Indicators
|
||||
- Very short, vague content
|
||||
- No technical details
|
||||
- Generic language (could be new user)
|
||||
- Suspicious links
|
||||
|
||||
### Low-Confidence Indicators
|
||||
- Unusual formatting
|
||||
- Non-English content (could be legitimate)
|
||||
- First-time contributor (not spam indicator alone)
|
||||
|
||||
## Analysis Process
|
||||
|
||||
1. **Content Analysis**: Check for promotional/offensive content
|
||||
2. **Link Analysis**: Evaluate any external links
|
||||
3. **Pattern Matching**: Check against known spam patterns
|
||||
4. **Context Check**: Is this related to the project at all?
|
||||
5. **Author Check**: New account with suspicious activity
|
||||
|
||||
## Output Format
|
||||
|
||||
```json
|
||||
{
|
||||
"is_spam": true,
|
||||
"confidence": 0.95,
|
||||
"spam_type": "promotional",
|
||||
"indicators": [
|
||||
"Contains promotional link to unrelated product",
|
||||
"No reference to project functionality",
|
||||
"Generic marketing language"
|
||||
],
|
||||
"recommendation": "flag_for_review",
|
||||
"explanation": "This issue contains a promotional link to an unrelated cryptocurrency trading platform with no connection to the project."
|
||||
}
|
||||
```
|
||||
|
||||
## Spam Types
|
||||
|
||||
- `promotional`: Advertising/marketing content
|
||||
- `abuse`: Offensive or harassing content
|
||||
- `gibberish`: Random/meaningless text
|
||||
- `bot_generated`: Automated spam submissions
|
||||
- `off_topic`: Completely unrelated to project
|
||||
- `test_submission`: Test/placeholder content
|
||||
|
||||
## Recommendations
|
||||
|
||||
- `flag_for_review`: Add label, wait for human decision
|
||||
- `needs_more_info`: Could be legitimate, needs clarification
|
||||
- `likely_legitimate`: Low confidence, probably not spam
|
||||
|
||||
## Important Guidelines
|
||||
|
||||
1. **Never auto-close**: Always flag for human review
|
||||
2. **Consider new users**: First issues may be poorly formatted
|
||||
3. **Language barriers**: Non-English ≠ spam
|
||||
4. **False positives are worse**: When in doubt, don't flag
|
||||
5. **No engagement**: Don't respond to obvious spam
|
||||
6. **Be respectful**: Even unclear issues might be genuine
|
||||
|
||||
## Not Spam (Common False Positives)
|
||||
|
||||
- Poorly written but genuine bug reports
|
||||
- Non-English issues (unless gibberish)
|
||||
- Issues with external links to relevant tools
|
||||
- First-time contributors with formatting issues
|
||||
- Automated test result submissions from CI
|
||||
- Issues from legitimate security researchers
|
||||
@@ -737,18 +737,26 @@ chmod +x init.sh
|
||||
|
||||
---
|
||||
|
||||
## PHASE 6: VERIFY PLAN FILES
|
||||
## PHASE 6: COMMIT IMPLEMENTATION PLAN
|
||||
|
||||
**IMPORTANT: Do NOT commit spec/plan files to git.**
|
||||
**IMPORTANT: Branch/worktree management is handled by the Python orchestrator.**
|
||||
Do NOT run `git checkout` or `git branch` commands - your workspace is already set up.
|
||||
|
||||
The following files are gitignored and should NOT be committed:
|
||||
- `implementation_plan.json` - tracked locally only
|
||||
- `init.sh` - tracked locally only
|
||||
- `build-progress.txt` - tracked locally only
|
||||
**Commit the implementation plan (if changes are present):**
|
||||
```bash
|
||||
# Add plan files
|
||||
git add implementation_plan.json init.sh
|
||||
|
||||
These files live in `.auto-claude/specs/` which is gitignored. The orchestrator handles syncing them between worktrees and the main project.
|
||||
# Check if there's anything to commit
|
||||
git diff --cached --quiet || git commit -m "auto-claude: Initialize subtask-based implementation plan
|
||||
|
||||
**Only code changes should be committed** - spec metadata stays local.
|
||||
- Workflow type: [type]
|
||||
- Phases: [N]
|
||||
- Subtasks: [N]
|
||||
- Ready for autonomous implementation"
|
||||
```
|
||||
|
||||
Note: If the commit fails (e.g., nothing to commit, or in a special workspace), that's okay - the plan is still saved.
|
||||
|
||||
---
|
||||
|
||||
@@ -800,7 +808,12 @@ Example:
|
||||
=== END SESSION 1 ===
|
||||
```
|
||||
|
||||
**Note:** Do NOT commit `build-progress.txt` - it is gitignored along with other spec files.
|
||||
**Commit progress:**
|
||||
|
||||
```bash
|
||||
git add build-progress.txt
|
||||
git commit -m "auto-claude: Add progress tracking"
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
@@ -813,8 +826,7 @@ Your session ends after:
|
||||
2. **Creating/updating context files** - project_index.json, context.json
|
||||
3. **Creating init.sh** - the setup script
|
||||
4. **Creating build-progress.txt** - progress tracking document
|
||||
|
||||
Note: These files are NOT committed to git - they are gitignored and managed locally.
|
||||
5. **Committing all planning files**
|
||||
|
||||
**STOP HERE. Do NOT:**
|
||||
- Start implementing any subtasks
|
||||
|
||||
@@ -427,9 +427,17 @@ cat > qa_report.md << 'EOF'
|
||||
[QA Report content]
|
||||
EOF
|
||||
|
||||
# Note: qa_report.md and implementation_plan.json are in .auto-claude/specs/ (gitignored)
|
||||
# Do NOT commit them - the framework tracks QA status automatically
|
||||
# Only commit actual code changes to the project
|
||||
git add qa_report.md implementation_plan.json
|
||||
git commit -m "qa: Sign off - all verification passed
|
||||
|
||||
- Unit tests: X/Y passing
|
||||
- Integration tests: X/Y passing
|
||||
- E2E tests: X/Y passing
|
||||
- Browser verification: complete
|
||||
- Security review: passed
|
||||
- No regressions found
|
||||
|
||||
🤖 QA Agent Session [N]"
|
||||
```
|
||||
|
||||
### If REJECTED:
|
||||
@@ -464,9 +472,16 @@ Once fixes are complete:
|
||||
|
||||
EOF
|
||||
|
||||
# Note: QA_FIX_REQUEST.md and implementation_plan.json are in .auto-claude/specs/ (gitignored)
|
||||
# Do NOT commit them - the framework tracks QA status automatically
|
||||
# Only commit actual code fixes to the project
|
||||
git add QA_FIX_REQUEST.md implementation_plan.json
|
||||
git commit -m "qa: Rejected - fixes required
|
||||
|
||||
Issues found:
|
||||
- [Issue 1]
|
||||
- [Issue 2]
|
||||
|
||||
See QA_FIX_REQUEST.md for details.
|
||||
|
||||
🤖 QA Agent Session [N]"
|
||||
```
|
||||
|
||||
Update `implementation_plan.json`:
|
||||
|
||||
@@ -20,7 +20,6 @@ from linear_updater import (
|
||||
linear_qa_started,
|
||||
)
|
||||
from phase_config import get_phase_model, get_phase_thinking_budget
|
||||
from phase_event import ExecutionPhase, emit_phase
|
||||
from progress import count_subtasks, is_build_complete
|
||||
from task_logger import (
|
||||
LogPhase,
|
||||
@@ -110,9 +109,6 @@ async def run_qa_validation_loop(
|
||||
print(f" Progress: {completed}/{total} subtasks completed")
|
||||
return False
|
||||
|
||||
# Emit phase event at start of QA validation (before any early returns)
|
||||
emit_phase(ExecutionPhase.QA_REVIEW, "Starting QA validation")
|
||||
|
||||
# Check if there's pending human feedback that needs to be processed
|
||||
fix_request_file = spec_dir / "QA_FIX_REQUEST.md"
|
||||
has_human_feedback = fix_request_file.exists()
|
||||
@@ -130,7 +126,6 @@ async def run_qa_validation_loop(
|
||||
"Human feedback detected - will run fixer first",
|
||||
fix_request_file=str(fix_request_file),
|
||||
)
|
||||
emit_phase(ExecutionPhase.QA_FIXING, "Processing human feedback")
|
||||
print("\n📝 Human feedback detected. Running QA Fixer first...")
|
||||
|
||||
# Get model and thinking budget for fixer (uses QA phase config)
|
||||
@@ -207,9 +202,6 @@ async def run_qa_validation_loop(
|
||||
)
|
||||
|
||||
print(f"\n--- QA Iteration {qa_iteration}/{MAX_QA_ITERATIONS} ---")
|
||||
emit_phase(
|
||||
ExecutionPhase.QA_REVIEW, f"Running QA review iteration {qa_iteration}"
|
||||
)
|
||||
|
||||
# Run QA reviewer with phase-specific model and thinking budget
|
||||
qa_model = get_phase_model(spec_dir, "qa", model)
|
||||
@@ -250,7 +242,6 @@ async def run_qa_validation_loop(
|
||||
)
|
||||
|
||||
if status == "approved":
|
||||
emit_phase(ExecutionPhase.COMPLETE, "QA validation passed")
|
||||
# Reset error tracking on success
|
||||
consecutive_errors = 0
|
||||
last_error_context = None
|
||||
@@ -374,7 +365,6 @@ async def run_qa_validation_loop(
|
||||
model=qa_model,
|
||||
thinking_budget=fixer_thinking_budget,
|
||||
)
|
||||
emit_phase(ExecutionPhase.QA_FIXING, "Fixing QA issues")
|
||||
print("\nRunning QA Fixer Agent...")
|
||||
|
||||
fix_client = create_client(
|
||||
@@ -465,7 +455,6 @@ async def run_qa_validation_loop(
|
||||
print("Retrying with error feedback...")
|
||||
|
||||
# Max iterations reached without approval
|
||||
emit_phase(ExecutionPhase.FAILED, "QA validation incomplete")
|
||||
debug_error(
|
||||
"qa_loop",
|
||||
"QA VALIDATION INCOMPLETE - max iterations reached",
|
||||
|
||||
@@ -12,6 +12,3 @@ graphiti-core>=0.5.0; python_version >= "3.12"
|
||||
|
||||
# Google AI (optional - for Gemini LLM and embeddings)
|
||||
google-generativeai>=0.8.0
|
||||
|
||||
# Pydantic for structured output schemas
|
||||
pydantic>=2.0.0
|
||||
|
||||
@@ -22,7 +22,7 @@ def _compute_file_hash(file_path: Path) -> str:
|
||||
return ""
|
||||
try:
|
||||
content = file_path.read_text(encoding="utf-8")
|
||||
return hashlib.md5(content.encode("utf-8"), usedforsecurity=False).hexdigest()
|
||||
return hashlib.md5(content.encode("utf-8")).hexdigest()
|
||||
except (OSError, UnicodeDecodeError):
|
||||
return ""
|
||||
|
||||
@@ -35,7 +35,7 @@ def _compute_spec_hash(spec_dir: Path) -> str:
|
||||
spec_hash = _compute_file_hash(spec_dir / "spec.md")
|
||||
plan_hash = _compute_file_hash(spec_dir / "implementation_plan.json")
|
||||
combined = f"{spec_hash}:{plan_hash}"
|
||||
return hashlib.md5(combined.encode("utf-8"), usedforsecurity=False).hexdigest()
|
||||
return hashlib.md5(combined.encode("utf-8")).hexdigest()
|
||||
|
||||
|
||||
@dataclass
|
||||
|
||||
@@ -1,41 +0,0 @@
|
||||
"""
|
||||
GitHub Automation Runners
|
||||
=========================
|
||||
|
||||
Standalone runner system for GitHub automation:
|
||||
- PR Review: AI-powered code review with fix suggestions
|
||||
- Issue Triage: Duplicate/spam/feature-creep detection
|
||||
- Issue Auto-Fix: Automatic spec creation and execution from issues
|
||||
|
||||
This is SEPARATE from the main task execution pipeline (spec_runner, run.py, etc.)
|
||||
to maintain modularity and avoid breaking existing features.
|
||||
"""
|
||||
|
||||
from .models import (
|
||||
AutoFixState,
|
||||
AutoFixStatus,
|
||||
GitHubRunnerConfig,
|
||||
PRReviewFinding,
|
||||
PRReviewResult,
|
||||
ReviewCategory,
|
||||
ReviewSeverity,
|
||||
TriageCategory,
|
||||
TriageResult,
|
||||
)
|
||||
from .orchestrator import GitHubOrchestrator
|
||||
|
||||
__all__ = [
|
||||
# Orchestrator
|
||||
"GitHubOrchestrator",
|
||||
# Models
|
||||
"PRReviewResult",
|
||||
"PRReviewFinding",
|
||||
"TriageResult",
|
||||
"AutoFixState",
|
||||
"GitHubRunnerConfig",
|
||||
# Enums
|
||||
"ReviewSeverity",
|
||||
"ReviewCategory",
|
||||
"TriageCategory",
|
||||
"AutoFixStatus",
|
||||
]
|
||||
@@ -1,738 +0,0 @@
|
||||
"""
|
||||
GitHub Automation Audit Logger
|
||||
==============================
|
||||
|
||||
Structured audit logging for all GitHub automation operations.
|
||||
Provides compliance trail, debugging support, and security audit capabilities.
|
||||
|
||||
Features:
|
||||
- JSON-formatted structured logs
|
||||
- Correlation ID generation per operation
|
||||
- Actor tracking (user/bot/automation)
|
||||
- Duration and token usage tracking
|
||||
- Log rotation with configurable retention
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import logging
|
||||
import time
|
||||
import uuid
|
||||
from contextlib import contextmanager
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import datetime, timezone
|
||||
from enum import Enum
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
# Configure module logger
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class AuditAction(str, Enum):
|
||||
"""Types of auditable actions."""
|
||||
|
||||
# PR Review actions
|
||||
PR_REVIEW_STARTED = "pr_review_started"
|
||||
PR_REVIEW_COMPLETED = "pr_review_completed"
|
||||
PR_REVIEW_FAILED = "pr_review_failed"
|
||||
PR_REVIEW_POSTED = "pr_review_posted"
|
||||
|
||||
# Issue Triage actions
|
||||
TRIAGE_STARTED = "triage_started"
|
||||
TRIAGE_COMPLETED = "triage_completed"
|
||||
TRIAGE_FAILED = "triage_failed"
|
||||
LABELS_APPLIED = "labels_applied"
|
||||
|
||||
# Auto-fix actions
|
||||
AUTOFIX_STARTED = "autofix_started"
|
||||
AUTOFIX_SPEC_CREATED = "autofix_spec_created"
|
||||
AUTOFIX_BUILD_STARTED = "autofix_build_started"
|
||||
AUTOFIX_PR_CREATED = "autofix_pr_created"
|
||||
AUTOFIX_COMPLETED = "autofix_completed"
|
||||
AUTOFIX_FAILED = "autofix_failed"
|
||||
AUTOFIX_CANCELLED = "autofix_cancelled"
|
||||
|
||||
# Permission actions
|
||||
PERMISSION_GRANTED = "permission_granted"
|
||||
PERMISSION_DENIED = "permission_denied"
|
||||
TOKEN_VERIFIED = "token_verified"
|
||||
|
||||
# Bot detection actions
|
||||
BOT_DETECTED = "bot_detected"
|
||||
REVIEW_SKIPPED = "review_skipped"
|
||||
|
||||
# Rate limiting actions
|
||||
RATE_LIMIT_WARNING = "rate_limit_warning"
|
||||
RATE_LIMIT_EXCEEDED = "rate_limit_exceeded"
|
||||
COST_LIMIT_WARNING = "cost_limit_warning"
|
||||
COST_LIMIT_EXCEEDED = "cost_limit_exceeded"
|
||||
|
||||
# GitHub API actions
|
||||
GITHUB_API_CALL = "github_api_call"
|
||||
GITHUB_API_ERROR = "github_api_error"
|
||||
GITHUB_API_TIMEOUT = "github_api_timeout"
|
||||
|
||||
# AI Agent actions
|
||||
AI_AGENT_STARTED = "ai_agent_started"
|
||||
AI_AGENT_COMPLETED = "ai_agent_completed"
|
||||
AI_AGENT_FAILED = "ai_agent_failed"
|
||||
|
||||
# Override actions
|
||||
OVERRIDE_APPLIED = "override_applied"
|
||||
CANCEL_REQUESTED = "cancel_requested"
|
||||
|
||||
# State transitions
|
||||
STATE_TRANSITION = "state_transition"
|
||||
|
||||
|
||||
class ActorType(str, Enum):
|
||||
"""Types of actors that can trigger actions."""
|
||||
|
||||
USER = "user"
|
||||
BOT = "bot"
|
||||
AUTOMATION = "automation"
|
||||
SYSTEM = "system"
|
||||
WEBHOOK = "webhook"
|
||||
|
||||
|
||||
@dataclass
|
||||
class AuditContext:
|
||||
"""Context for an auditable operation."""
|
||||
|
||||
correlation_id: str
|
||||
actor_type: ActorType
|
||||
actor_id: str | None = None
|
||||
repo: str | None = None
|
||||
pr_number: int | None = None
|
||||
issue_number: int | None = None
|
||||
started_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
|
||||
metadata: dict[str, Any] = field(default_factory=dict)
|
||||
|
||||
def to_dict(self) -> dict[str, Any]:
|
||||
return {
|
||||
"correlation_id": self.correlation_id,
|
||||
"actor_type": self.actor_type.value,
|
||||
"actor_id": self.actor_id,
|
||||
"repo": self.repo,
|
||||
"pr_number": self.pr_number,
|
||||
"issue_number": self.issue_number,
|
||||
"started_at": self.started_at.isoformat(),
|
||||
"metadata": self.metadata,
|
||||
}
|
||||
|
||||
|
||||
@dataclass
|
||||
class AuditEntry:
|
||||
"""A single audit log entry."""
|
||||
|
||||
timestamp: datetime
|
||||
correlation_id: str
|
||||
action: AuditAction
|
||||
actor_type: ActorType
|
||||
actor_id: str | None
|
||||
repo: str | None
|
||||
pr_number: int | None
|
||||
issue_number: int | None
|
||||
result: str # success, failure, skipped
|
||||
duration_ms: int | None
|
||||
error: str | None
|
||||
details: dict[str, Any]
|
||||
token_usage: dict[str, int] | None # input_tokens, output_tokens
|
||||
|
||||
def to_dict(self) -> dict[str, Any]:
|
||||
return {
|
||||
"timestamp": self.timestamp.isoformat(),
|
||||
"correlation_id": self.correlation_id,
|
||||
"action": self.action.value,
|
||||
"actor_type": self.actor_type.value,
|
||||
"actor_id": self.actor_id,
|
||||
"repo": self.repo,
|
||||
"pr_number": self.pr_number,
|
||||
"issue_number": self.issue_number,
|
||||
"result": self.result,
|
||||
"duration_ms": self.duration_ms,
|
||||
"error": self.error,
|
||||
"details": self.details,
|
||||
"token_usage": self.token_usage,
|
||||
}
|
||||
|
||||
def to_json(self) -> str:
|
||||
return json.dumps(self.to_dict(), default=str)
|
||||
|
||||
|
||||
class AuditLogger:
|
||||
"""
|
||||
Structured audit logger for GitHub automation.
|
||||
|
||||
Usage:
|
||||
audit = AuditLogger(log_dir=Path(".auto-claude/github/audit"))
|
||||
|
||||
# Start an operation with context
|
||||
ctx = audit.start_operation(
|
||||
actor_type=ActorType.USER,
|
||||
actor_id="username",
|
||||
repo="owner/repo",
|
||||
pr_number=123,
|
||||
)
|
||||
|
||||
# Log events during the operation
|
||||
audit.log(ctx, AuditAction.PR_REVIEW_STARTED)
|
||||
|
||||
# ... do work ...
|
||||
|
||||
# Log completion with details
|
||||
audit.log(
|
||||
ctx,
|
||||
AuditAction.PR_REVIEW_COMPLETED,
|
||||
result="success",
|
||||
details={"findings_count": 5},
|
||||
)
|
||||
"""
|
||||
|
||||
_instance: AuditLogger | None = None
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
log_dir: Path | None = None,
|
||||
retention_days: int = 30,
|
||||
max_file_size_mb: int = 100,
|
||||
enabled: bool = True,
|
||||
):
|
||||
"""
|
||||
Initialize audit logger.
|
||||
|
||||
Args:
|
||||
log_dir: Directory for audit logs (default: .auto-claude/github/audit)
|
||||
retention_days: Days to retain logs (default: 30)
|
||||
max_file_size_mb: Max size per log file before rotation (default: 100MB)
|
||||
enabled: Whether audit logging is enabled (default: True)
|
||||
"""
|
||||
self.log_dir = log_dir or Path(".auto-claude/github/audit")
|
||||
self.retention_days = retention_days
|
||||
self.max_file_size_mb = max_file_size_mb
|
||||
self.enabled = enabled
|
||||
|
||||
if enabled:
|
||||
self.log_dir.mkdir(parents=True, exist_ok=True)
|
||||
self._current_log_file: Path | None = None
|
||||
self._rotate_if_needed()
|
||||
|
||||
@classmethod
|
||||
def get_instance(
|
||||
cls,
|
||||
log_dir: Path | None = None,
|
||||
**kwargs,
|
||||
) -> AuditLogger:
|
||||
"""Get or create singleton instance."""
|
||||
if cls._instance is None:
|
||||
cls._instance = cls(log_dir=log_dir, **kwargs)
|
||||
return cls._instance
|
||||
|
||||
@classmethod
|
||||
def reset_instance(cls) -> None:
|
||||
"""Reset singleton (for testing)."""
|
||||
cls._instance = None
|
||||
|
||||
def _get_log_file_path(self) -> Path:
|
||||
"""Get path for current day's log file."""
|
||||
date_str = datetime.now(timezone.utc).strftime("%Y-%m-%d")
|
||||
return self.log_dir / f"audit_{date_str}.jsonl"
|
||||
|
||||
def _rotate_if_needed(self) -> None:
|
||||
"""Rotate log file if it exceeds max size."""
|
||||
if not self.enabled:
|
||||
return
|
||||
|
||||
log_file = self._get_log_file_path()
|
||||
|
||||
if log_file.exists():
|
||||
size_mb = log_file.stat().st_size / (1024 * 1024)
|
||||
if size_mb >= self.max_file_size_mb:
|
||||
# Rotate: add timestamp suffix
|
||||
timestamp = datetime.now(timezone.utc).strftime("%H%M%S")
|
||||
rotated = log_file.with_suffix(f".{timestamp}.jsonl")
|
||||
log_file.rename(rotated)
|
||||
logger.info(f"Rotated audit log to {rotated}")
|
||||
|
||||
self._current_log_file = log_file
|
||||
|
||||
def _cleanup_old_logs(self) -> None:
|
||||
"""Remove logs older than retention period."""
|
||||
if not self.enabled or not self.log_dir.exists():
|
||||
return
|
||||
|
||||
cutoff = datetime.now(timezone.utc).timestamp() - (
|
||||
self.retention_days * 24 * 60 * 60
|
||||
)
|
||||
|
||||
for log_file in self.log_dir.glob("audit_*.jsonl"):
|
||||
if log_file.stat().st_mtime < cutoff:
|
||||
log_file.unlink()
|
||||
logger.info(f"Deleted old audit log: {log_file}")
|
||||
|
||||
def generate_correlation_id(self) -> str:
|
||||
"""Generate a unique correlation ID for an operation."""
|
||||
return f"gh-{uuid.uuid4().hex[:12]}"
|
||||
|
||||
def start_operation(
|
||||
self,
|
||||
actor_type: ActorType,
|
||||
actor_id: str | None = None,
|
||||
repo: str | None = None,
|
||||
pr_number: int | None = None,
|
||||
issue_number: int | None = None,
|
||||
correlation_id: str | None = None,
|
||||
metadata: dict[str, Any] | None = None,
|
||||
) -> AuditContext:
|
||||
"""
|
||||
Start a new auditable operation.
|
||||
|
||||
Args:
|
||||
actor_type: Type of actor (USER, BOT, AUTOMATION, SYSTEM)
|
||||
actor_id: Identifier for the actor (username, bot name, etc.)
|
||||
repo: Repository in owner/repo format
|
||||
pr_number: PR number if applicable
|
||||
issue_number: Issue number if applicable
|
||||
correlation_id: Optional existing correlation ID
|
||||
metadata: Additional context metadata
|
||||
|
||||
Returns:
|
||||
AuditContext for use with log() calls
|
||||
"""
|
||||
return AuditContext(
|
||||
correlation_id=correlation_id or self.generate_correlation_id(),
|
||||
actor_type=actor_type,
|
||||
actor_id=actor_id,
|
||||
repo=repo,
|
||||
pr_number=pr_number,
|
||||
issue_number=issue_number,
|
||||
metadata=metadata or {},
|
||||
)
|
||||
|
||||
def log(
|
||||
self,
|
||||
context: AuditContext,
|
||||
action: AuditAction,
|
||||
result: str = "success",
|
||||
error: str | None = None,
|
||||
details: dict[str, Any] | None = None,
|
||||
token_usage: dict[str, int] | None = None,
|
||||
duration_ms: int | None = None,
|
||||
) -> AuditEntry:
|
||||
"""
|
||||
Log an audit event.
|
||||
|
||||
Args:
|
||||
context: Audit context from start_operation()
|
||||
action: The action being logged
|
||||
result: Result status (success, failure, skipped)
|
||||
error: Error message if failed
|
||||
details: Additional details about the action
|
||||
token_usage: Token usage if AI-related (input_tokens, output_tokens)
|
||||
duration_ms: Duration in milliseconds if timed
|
||||
|
||||
Returns:
|
||||
The created AuditEntry
|
||||
"""
|
||||
# Calculate duration from context start if not provided
|
||||
if duration_ms is None and context.started_at:
|
||||
elapsed = datetime.now(timezone.utc) - context.started_at
|
||||
duration_ms = int(elapsed.total_seconds() * 1000)
|
||||
|
||||
entry = AuditEntry(
|
||||
timestamp=datetime.now(timezone.utc),
|
||||
correlation_id=context.correlation_id,
|
||||
action=action,
|
||||
actor_type=context.actor_type,
|
||||
actor_id=context.actor_id,
|
||||
repo=context.repo,
|
||||
pr_number=context.pr_number,
|
||||
issue_number=context.issue_number,
|
||||
result=result,
|
||||
duration_ms=duration_ms,
|
||||
error=error,
|
||||
details=details or {},
|
||||
token_usage=token_usage,
|
||||
)
|
||||
|
||||
self._write_entry(entry)
|
||||
return entry
|
||||
|
||||
def _write_entry(self, entry: AuditEntry) -> None:
|
||||
"""Write an entry to the log file."""
|
||||
if not self.enabled:
|
||||
return
|
||||
|
||||
self._rotate_if_needed()
|
||||
|
||||
try:
|
||||
log_file = self._get_log_file_path()
|
||||
with open(log_file, "a") as f:
|
||||
f.write(entry.to_json() + "\n")
|
||||
except Exception as e:
|
||||
logger.error(f"Failed to write audit log: {e}")
|
||||
|
||||
@contextmanager
|
||||
def operation(
|
||||
self,
|
||||
action_start: AuditAction,
|
||||
action_complete: AuditAction,
|
||||
action_failed: AuditAction,
|
||||
actor_type: ActorType,
|
||||
actor_id: str | None = None,
|
||||
repo: str | None = None,
|
||||
pr_number: int | None = None,
|
||||
issue_number: int | None = None,
|
||||
metadata: dict[str, Any] | None = None,
|
||||
):
|
||||
"""
|
||||
Context manager for auditing an operation.
|
||||
|
||||
Usage:
|
||||
with audit.operation(
|
||||
action_start=AuditAction.PR_REVIEW_STARTED,
|
||||
action_complete=AuditAction.PR_REVIEW_COMPLETED,
|
||||
action_failed=AuditAction.PR_REVIEW_FAILED,
|
||||
actor_type=ActorType.AUTOMATION,
|
||||
repo="owner/repo",
|
||||
pr_number=123,
|
||||
) as ctx:
|
||||
# Do work
|
||||
ctx.metadata["findings_count"] = 5
|
||||
|
||||
Automatically logs start, completion, and failure with timing.
|
||||
"""
|
||||
ctx = self.start_operation(
|
||||
actor_type=actor_type,
|
||||
actor_id=actor_id,
|
||||
repo=repo,
|
||||
pr_number=pr_number,
|
||||
issue_number=issue_number,
|
||||
metadata=metadata,
|
||||
)
|
||||
|
||||
self.log(ctx, action_start, result="started")
|
||||
start_time = time.monotonic()
|
||||
|
||||
try:
|
||||
yield ctx
|
||||
duration_ms = int((time.monotonic() - start_time) * 1000)
|
||||
self.log(
|
||||
ctx,
|
||||
action_complete,
|
||||
result="success",
|
||||
details=ctx.metadata,
|
||||
duration_ms=duration_ms,
|
||||
)
|
||||
except Exception as e:
|
||||
duration_ms = int((time.monotonic() - start_time) * 1000)
|
||||
self.log(
|
||||
ctx,
|
||||
action_failed,
|
||||
result="failure",
|
||||
error=str(e),
|
||||
details=ctx.metadata,
|
||||
duration_ms=duration_ms,
|
||||
)
|
||||
raise
|
||||
|
||||
def log_github_api_call(
|
||||
self,
|
||||
context: AuditContext,
|
||||
endpoint: str,
|
||||
method: str = "GET",
|
||||
status_code: int | None = None,
|
||||
duration_ms: int | None = None,
|
||||
error: str | None = None,
|
||||
) -> None:
|
||||
"""Log a GitHub API call."""
|
||||
action = (
|
||||
AuditAction.GITHUB_API_CALL if not error else AuditAction.GITHUB_API_ERROR
|
||||
)
|
||||
self.log(
|
||||
context,
|
||||
action,
|
||||
result="success" if not error else "failure",
|
||||
error=error,
|
||||
details={
|
||||
"endpoint": endpoint,
|
||||
"method": method,
|
||||
"status_code": status_code,
|
||||
},
|
||||
duration_ms=duration_ms,
|
||||
)
|
||||
|
||||
def log_ai_agent(
|
||||
self,
|
||||
context: AuditContext,
|
||||
agent_type: str,
|
||||
model: str,
|
||||
input_tokens: int | None = None,
|
||||
output_tokens: int | None = None,
|
||||
duration_ms: int | None = None,
|
||||
error: str | None = None,
|
||||
) -> None:
|
||||
"""Log an AI agent invocation."""
|
||||
action = (
|
||||
AuditAction.AI_AGENT_COMPLETED if not error else AuditAction.AI_AGENT_FAILED
|
||||
)
|
||||
self.log(
|
||||
context,
|
||||
action,
|
||||
result="success" if not error else "failure",
|
||||
error=error,
|
||||
details={
|
||||
"agent_type": agent_type,
|
||||
"model": model,
|
||||
},
|
||||
token_usage={
|
||||
"input_tokens": input_tokens or 0,
|
||||
"output_tokens": output_tokens or 0,
|
||||
},
|
||||
duration_ms=duration_ms,
|
||||
)
|
||||
|
||||
def log_permission_check(
|
||||
self,
|
||||
context: AuditContext,
|
||||
allowed: bool,
|
||||
reason: str,
|
||||
username: str | None = None,
|
||||
role: str | None = None,
|
||||
) -> None:
|
||||
"""Log a permission check result."""
|
||||
action = (
|
||||
AuditAction.PERMISSION_GRANTED if allowed else AuditAction.PERMISSION_DENIED
|
||||
)
|
||||
self.log(
|
||||
context,
|
||||
action,
|
||||
result="granted" if allowed else "denied",
|
||||
details={
|
||||
"reason": reason,
|
||||
"username": username,
|
||||
"role": role,
|
||||
},
|
||||
)
|
||||
|
||||
def log_state_transition(
|
||||
self,
|
||||
context: AuditContext,
|
||||
from_state: str,
|
||||
to_state: str,
|
||||
reason: str | None = None,
|
||||
) -> None:
|
||||
"""Log a state machine transition."""
|
||||
self.log(
|
||||
context,
|
||||
AuditAction.STATE_TRANSITION,
|
||||
details={
|
||||
"from_state": from_state,
|
||||
"to_state": to_state,
|
||||
"reason": reason,
|
||||
},
|
||||
)
|
||||
|
||||
def log_override(
|
||||
self,
|
||||
context: AuditContext,
|
||||
override_type: str,
|
||||
original_action: str,
|
||||
actor_id: str,
|
||||
) -> None:
|
||||
"""Log a user override action."""
|
||||
self.log(
|
||||
context,
|
||||
AuditAction.OVERRIDE_APPLIED,
|
||||
details={
|
||||
"override_type": override_type,
|
||||
"original_action": original_action,
|
||||
"overridden_by": actor_id,
|
||||
},
|
||||
)
|
||||
|
||||
def query_logs(
|
||||
self,
|
||||
correlation_id: str | None = None,
|
||||
action: AuditAction | None = None,
|
||||
repo: str | None = None,
|
||||
pr_number: int | None = None,
|
||||
issue_number: int | None = None,
|
||||
since: datetime | None = None,
|
||||
limit: int = 100,
|
||||
) -> list[AuditEntry]:
|
||||
"""
|
||||
Query audit logs with filters.
|
||||
|
||||
Args:
|
||||
correlation_id: Filter by correlation ID
|
||||
action: Filter by action type
|
||||
repo: Filter by repository
|
||||
pr_number: Filter by PR number
|
||||
issue_number: Filter by issue number
|
||||
since: Only entries after this time
|
||||
limit: Maximum entries to return
|
||||
|
||||
Returns:
|
||||
List of matching AuditEntry objects
|
||||
"""
|
||||
if not self.enabled or not self.log_dir.exists():
|
||||
return []
|
||||
|
||||
results = []
|
||||
|
||||
for log_file in sorted(self.log_dir.glob("audit_*.jsonl"), reverse=True):
|
||||
try:
|
||||
with open(log_file) as f:
|
||||
for line in f:
|
||||
if not line.strip():
|
||||
continue
|
||||
|
||||
try:
|
||||
data = json.loads(line)
|
||||
except json.JSONDecodeError:
|
||||
continue
|
||||
|
||||
# Apply filters
|
||||
if (
|
||||
correlation_id
|
||||
and data.get("correlation_id") != correlation_id
|
||||
):
|
||||
continue
|
||||
if action and data.get("action") != action.value:
|
||||
continue
|
||||
if repo and data.get("repo") != repo:
|
||||
continue
|
||||
if pr_number and data.get("pr_number") != pr_number:
|
||||
continue
|
||||
if issue_number and data.get("issue_number") != issue_number:
|
||||
continue
|
||||
if since:
|
||||
entry_time = datetime.fromisoformat(data["timestamp"])
|
||||
if entry_time < since:
|
||||
continue
|
||||
|
||||
# Reconstruct entry
|
||||
entry = AuditEntry(
|
||||
timestamp=datetime.fromisoformat(data["timestamp"]),
|
||||
correlation_id=data["correlation_id"],
|
||||
action=AuditAction(data["action"]),
|
||||
actor_type=ActorType(data["actor_type"]),
|
||||
actor_id=data.get("actor_id"),
|
||||
repo=data.get("repo"),
|
||||
pr_number=data.get("pr_number"),
|
||||
issue_number=data.get("issue_number"),
|
||||
result=data["result"],
|
||||
duration_ms=data.get("duration_ms"),
|
||||
error=data.get("error"),
|
||||
details=data.get("details", {}),
|
||||
token_usage=data.get("token_usage"),
|
||||
)
|
||||
results.append(entry)
|
||||
|
||||
if len(results) >= limit:
|
||||
return results
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Error reading audit log {log_file}: {e}")
|
||||
|
||||
return results
|
||||
|
||||
def get_operation_history(self, correlation_id: str) -> list[AuditEntry]:
|
||||
"""Get all entries for a specific operation by correlation ID."""
|
||||
return self.query_logs(correlation_id=correlation_id, limit=1000)
|
||||
|
||||
def get_statistics(
|
||||
self,
|
||||
repo: str | None = None,
|
||||
since: datetime | None = None,
|
||||
) -> dict[str, Any]:
|
||||
"""
|
||||
Get aggregate statistics from audit logs.
|
||||
|
||||
Returns:
|
||||
Dictionary with counts by action, result, and actor type
|
||||
"""
|
||||
entries = self.query_logs(repo=repo, since=since, limit=10000)
|
||||
|
||||
stats = {
|
||||
"total_entries": len(entries),
|
||||
"by_action": {},
|
||||
"by_result": {},
|
||||
"by_actor_type": {},
|
||||
"total_duration_ms": 0,
|
||||
"total_input_tokens": 0,
|
||||
"total_output_tokens": 0,
|
||||
}
|
||||
|
||||
for entry in entries:
|
||||
# Count by action
|
||||
action = entry.action.value
|
||||
stats["by_action"][action] = stats["by_action"].get(action, 0) + 1
|
||||
|
||||
# Count by result
|
||||
result = entry.result
|
||||
stats["by_result"][result] = stats["by_result"].get(result, 0) + 1
|
||||
|
||||
# Count by actor type
|
||||
actor = entry.actor_type.value
|
||||
stats["by_actor_type"][actor] = stats["by_actor_type"].get(actor, 0) + 1
|
||||
|
||||
# Sum durations
|
||||
if entry.duration_ms:
|
||||
stats["total_duration_ms"] += entry.duration_ms
|
||||
|
||||
# Sum token usage
|
||||
if entry.token_usage:
|
||||
stats["total_input_tokens"] += entry.token_usage.get("input_tokens", 0)
|
||||
stats["total_output_tokens"] += entry.token_usage.get(
|
||||
"output_tokens", 0
|
||||
)
|
||||
|
||||
return stats
|
||||
|
||||
|
||||
# Convenience functions for quick logging
|
||||
def get_audit_logger() -> AuditLogger:
|
||||
"""Get the global audit logger instance."""
|
||||
return AuditLogger.get_instance()
|
||||
|
||||
|
||||
def audit_operation(
|
||||
action_start: AuditAction,
|
||||
action_complete: AuditAction,
|
||||
action_failed: AuditAction,
|
||||
**kwargs,
|
||||
):
|
||||
"""Decorator for auditing function calls."""
|
||||
|
||||
def decorator(func):
|
||||
async def async_wrapper(*args, **func_kwargs):
|
||||
audit = get_audit_logger()
|
||||
with audit.operation(
|
||||
action_start=action_start,
|
||||
action_complete=action_complete,
|
||||
action_failed=action_failed,
|
||||
**kwargs,
|
||||
) as ctx:
|
||||
return await func(*args, audit_context=ctx, **func_kwargs)
|
||||
|
||||
def sync_wrapper(*args, **func_kwargs):
|
||||
audit = get_audit_logger()
|
||||
with audit.operation(
|
||||
action_start=action_start,
|
||||
action_complete=action_complete,
|
||||
action_failed=action_failed,
|
||||
**kwargs,
|
||||
) as ctx:
|
||||
return func(*args, audit_context=ctx, **func_kwargs)
|
||||
|
||||
import asyncio
|
||||
|
||||
if asyncio.iscoroutinefunction(func):
|
||||
return async_wrapper
|
||||
return sync_wrapper
|
||||
|
||||
return decorator
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,326 +0,0 @@
|
||||
"""
|
||||
Batch Validation Agent
|
||||
======================
|
||||
|
||||
AI layer that validates issue batching using Claude SDK with extended thinking.
|
||||
Reviews whether semantically grouped issues actually belong together.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import importlib.util
|
||||
import json
|
||||
import logging
|
||||
from dataclasses import dataclass
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# Check for Claude SDK availability without importing (avoids unused import warning)
|
||||
CLAUDE_SDK_AVAILABLE = importlib.util.find_spec("claude_agent_sdk") is not None
|
||||
|
||||
# Default model and thinking configuration
|
||||
DEFAULT_MODEL = "claude-sonnet-4-20250514"
|
||||
DEFAULT_THINKING_BUDGET = 10000 # Medium thinking
|
||||
|
||||
|
||||
@dataclass
|
||||
class BatchValidationResult:
|
||||
"""Result of batch validation."""
|
||||
|
||||
batch_id: str
|
||||
is_valid: bool
|
||||
confidence: float # 0.0 - 1.0
|
||||
reasoning: str
|
||||
suggested_splits: list[list[int]] | None # If invalid, suggest how to split
|
||||
common_theme: str # Refined theme description
|
||||
|
||||
def to_dict(self) -> dict[str, Any]:
|
||||
return {
|
||||
"batch_id": self.batch_id,
|
||||
"is_valid": self.is_valid,
|
||||
"confidence": self.confidence,
|
||||
"reasoning": self.reasoning,
|
||||
"suggested_splits": self.suggested_splits,
|
||||
"common_theme": self.common_theme,
|
||||
}
|
||||
|
||||
|
||||
VALIDATION_PROMPT = """You are reviewing a batch of GitHub issues that were grouped together by semantic similarity.
|
||||
Your job is to validate whether these issues truly belong together for a SINGLE combined fix/PR.
|
||||
|
||||
Issues should be batched together ONLY if:
|
||||
1. They describe the SAME root cause or closely related symptoms
|
||||
2. They can realistically be fixed together in ONE pull request
|
||||
3. Fixing one would naturally address the others
|
||||
4. They affect the same component/area of the codebase
|
||||
|
||||
Issues should NOT be batched together if:
|
||||
1. They are merely topically similar but have different root causes
|
||||
2. They require separate, unrelated fixes
|
||||
3. One is a feature request and another is a bug fix
|
||||
4. They affect completely different parts of the codebase
|
||||
|
||||
## Batch to Validate
|
||||
|
||||
Batch ID: {batch_id}
|
||||
Primary Issue: #{primary_issue}
|
||||
Detected Themes: {themes}
|
||||
|
||||
### Issues in this batch:
|
||||
|
||||
{issues_formatted}
|
||||
|
||||
## Your Task
|
||||
|
||||
Analyze whether these issues truly belong together. Consider:
|
||||
- Do they share a common root cause?
|
||||
- Could a single PR reasonably fix all of them?
|
||||
- Are there any outliers that don't fit?
|
||||
|
||||
Respond with a JSON object:
|
||||
```json
|
||||
{{
|
||||
"is_valid": true/false,
|
||||
"confidence": 0.0-1.0,
|
||||
"reasoning": "Brief explanation of your decision",
|
||||
"suggested_splits": null or [[issue_numbers], [issue_numbers]] if invalid,
|
||||
"common_theme": "Refined description of what ties valid issues together"
|
||||
}}
|
||||
```
|
||||
|
||||
Only output the JSON, no other text."""
|
||||
|
||||
|
||||
class BatchValidator:
|
||||
"""
|
||||
Validates issue batches using Claude SDK with extended thinking.
|
||||
|
||||
Usage:
|
||||
validator = BatchValidator(project_dir=Path("."))
|
||||
result = await validator.validate_batch(batch)
|
||||
|
||||
if not result.is_valid:
|
||||
# Split the batch according to suggestions
|
||||
new_batches = result.suggested_splits
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
project_dir: Path | None = None,
|
||||
model: str = DEFAULT_MODEL,
|
||||
thinking_budget: int = DEFAULT_THINKING_BUDGET,
|
||||
):
|
||||
self.model = model
|
||||
self.thinking_budget = thinking_budget
|
||||
self.project_dir = project_dir or Path.cwd()
|
||||
|
||||
if not CLAUDE_SDK_AVAILABLE:
|
||||
logger.warning(
|
||||
"claude-agent-sdk not available. Batch validation will be skipped."
|
||||
)
|
||||
|
||||
def _format_issues(self, issues: list[dict[str, Any]]) -> str:
|
||||
"""Format issues for the prompt."""
|
||||
formatted = []
|
||||
for issue in issues:
|
||||
labels = ", ".join(issue.get("labels", [])) or "none"
|
||||
body = issue.get("body", "")[:500] # Truncate long bodies
|
||||
if len(issue.get("body", "")) > 500:
|
||||
body += "..."
|
||||
|
||||
formatted.append(f"""
|
||||
**Issue #{issue["issue_number"]}**: {issue["title"]}
|
||||
- Labels: {labels}
|
||||
- Similarity to primary: {issue.get("similarity_to_primary", 1.0):.0%}
|
||||
- Body: {body}
|
||||
""")
|
||||
return "\n---\n".join(formatted)
|
||||
|
||||
async def validate_batch(
|
||||
self,
|
||||
batch_id: str,
|
||||
primary_issue: int,
|
||||
issues: list[dict[str, Any]],
|
||||
themes: list[str],
|
||||
) -> BatchValidationResult:
|
||||
"""
|
||||
Validate a batch of issues.
|
||||
|
||||
Args:
|
||||
batch_id: Unique batch identifier
|
||||
primary_issue: The primary/anchor issue number
|
||||
issues: List of issue dicts with issue_number, title, body, labels, similarity_to_primary
|
||||
themes: Detected common themes
|
||||
|
||||
Returns:
|
||||
BatchValidationResult with validation decision
|
||||
"""
|
||||
# Single issue batches are always valid
|
||||
if len(issues) <= 1:
|
||||
return BatchValidationResult(
|
||||
batch_id=batch_id,
|
||||
is_valid=True,
|
||||
confidence=1.0,
|
||||
reasoning="Single issue batch - no validation needed",
|
||||
suggested_splits=None,
|
||||
common_theme=themes[0] if themes else "single issue",
|
||||
)
|
||||
|
||||
# Check if SDK is available
|
||||
if not CLAUDE_SDK_AVAILABLE:
|
||||
logger.warning("Claude SDK not available, assuming batch is valid")
|
||||
return BatchValidationResult(
|
||||
batch_id=batch_id,
|
||||
is_valid=True,
|
||||
confidence=0.5,
|
||||
reasoning="Validation skipped - Claude SDK not available",
|
||||
suggested_splits=None,
|
||||
common_theme=themes[0] if themes else "",
|
||||
)
|
||||
|
||||
# Format the prompt
|
||||
prompt = VALIDATION_PROMPT.format(
|
||||
batch_id=batch_id,
|
||||
primary_issue=primary_issue,
|
||||
themes=", ".join(themes) if themes else "none detected",
|
||||
issues_formatted=self._format_issues(issues),
|
||||
)
|
||||
|
||||
try:
|
||||
# Create settings for minimal permissions (no tools needed)
|
||||
settings = {
|
||||
"permissions": {
|
||||
"defaultMode": "ignore",
|
||||
"allow": [],
|
||||
},
|
||||
}
|
||||
|
||||
settings_file = self.project_dir / ".batch_validator_settings.json"
|
||||
with open(settings_file, "w") as f:
|
||||
json.dump(settings, f)
|
||||
|
||||
try:
|
||||
# Create Claude SDK client with extended thinking
|
||||
from core.simple_client import create_simple_client
|
||||
|
||||
client = create_simple_client(
|
||||
agent_type="batch_validation",
|
||||
model=self.model,
|
||||
system_prompt="You are an expert at analyzing GitHub issues and determining if they should be grouped together for a combined fix.",
|
||||
cwd=self.project_dir,
|
||||
max_thinking_tokens=self.thinking_budget, # Extended thinking
|
||||
)
|
||||
|
||||
async with client:
|
||||
await client.query(prompt)
|
||||
result_text = await self._collect_response(client)
|
||||
|
||||
# Parse JSON response
|
||||
result_json = self._parse_json_response(result_text)
|
||||
|
||||
return BatchValidationResult(
|
||||
batch_id=batch_id,
|
||||
is_valid=result_json.get("is_valid", True),
|
||||
confidence=result_json.get("confidence", 0.5),
|
||||
reasoning=result_json.get("reasoning", "No reasoning provided"),
|
||||
suggested_splits=result_json.get("suggested_splits"),
|
||||
common_theme=result_json.get("common_theme", ""),
|
||||
)
|
||||
|
||||
finally:
|
||||
# Cleanup settings file
|
||||
if settings_file.exists():
|
||||
settings_file.unlink()
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Batch validation failed: {e}")
|
||||
# On error, assume valid to not block the flow
|
||||
return BatchValidationResult(
|
||||
batch_id=batch_id,
|
||||
is_valid=True,
|
||||
confidence=0.5,
|
||||
reasoning=f"Validation error (assuming valid): {str(e)}",
|
||||
suggested_splits=None,
|
||||
common_theme=themes[0] if themes else "",
|
||||
)
|
||||
|
||||
async def _collect_response(self, client: Any) -> str:
|
||||
"""Collect text response from Claude client."""
|
||||
response_text = ""
|
||||
|
||||
async for msg in client.receive_response():
|
||||
msg_type = type(msg).__name__
|
||||
|
||||
if msg_type == "AssistantMessage":
|
||||
for content in msg.content:
|
||||
if hasattr(content, "text"):
|
||||
response_text += content.text
|
||||
|
||||
return response_text
|
||||
|
||||
def _parse_json_response(self, text: str) -> dict[str, Any]:
|
||||
"""Parse JSON from the response, handling markdown code blocks."""
|
||||
# Try to extract JSON from markdown code block
|
||||
if "```json" in text:
|
||||
start = text.find("```json") + 7
|
||||
end = text.find("```", start)
|
||||
if end > start:
|
||||
text = text[start:end].strip()
|
||||
elif "```" in text:
|
||||
start = text.find("```") + 3
|
||||
end = text.find("```", start)
|
||||
if end > start:
|
||||
text = text[start:end].strip()
|
||||
|
||||
try:
|
||||
return json.loads(text)
|
||||
except json.JSONDecodeError:
|
||||
# Try to find JSON object in text
|
||||
start = text.find("{")
|
||||
end = text.rfind("}") + 1
|
||||
if start >= 0 and end > start:
|
||||
return json.loads(text[start:end])
|
||||
raise
|
||||
|
||||
|
||||
async def validate_batches(
|
||||
batches: list[dict[str, Any]],
|
||||
project_dir: Path | None = None,
|
||||
model: str = DEFAULT_MODEL,
|
||||
thinking_budget: int = DEFAULT_THINKING_BUDGET,
|
||||
) -> list[BatchValidationResult]:
|
||||
"""
|
||||
Validate multiple batches.
|
||||
|
||||
Args:
|
||||
batches: List of batch dicts with batch_id, primary_issue, issues, common_themes
|
||||
project_dir: Project directory for Claude SDK
|
||||
model: Model to use for validation
|
||||
thinking_budget: Token budget for extended thinking
|
||||
|
||||
Returns:
|
||||
List of BatchValidationResult
|
||||
"""
|
||||
validator = BatchValidator(
|
||||
project_dir=project_dir,
|
||||
model=model,
|
||||
thinking_budget=thinking_budget,
|
||||
)
|
||||
results = []
|
||||
|
||||
for batch in batches:
|
||||
result = await validator.validate_batch(
|
||||
batch_id=batch["batch_id"],
|
||||
primary_issue=batch["primary_issue"],
|
||||
issues=batch["issues"],
|
||||
themes=batch.get("common_themes", []),
|
||||
)
|
||||
results.append(result)
|
||||
logger.info(
|
||||
f"Batch {batch['batch_id']}: valid={result.is_valid}, "
|
||||
f"confidence={result.confidence:.0%}, theme='{result.common_theme}'"
|
||||
)
|
||||
|
||||
return results
|
||||
@@ -1,405 +0,0 @@
|
||||
"""
|
||||
Bot Detection for GitHub Automation
|
||||
====================================
|
||||
|
||||
Prevents infinite loops by detecting when the bot is reviewing its own work.
|
||||
|
||||
Key Features:
|
||||
- Identifies bot user from configured token
|
||||
- Skips PRs authored by the bot
|
||||
- Skips re-reviewing bot commits
|
||||
- Implements "cooling off" period to prevent rapid re-reviews
|
||||
- Tracks reviewed commits to avoid duplicate reviews
|
||||
|
||||
Usage:
|
||||
detector = BotDetector(bot_token="ghp_...")
|
||||
|
||||
# Check if PR should be skipped
|
||||
should_skip, reason = detector.should_skip_pr_review(pr_data, commits)
|
||||
if should_skip:
|
||||
print(f"Skipping PR: {reason}")
|
||||
return
|
||||
|
||||
# After successful review, mark as reviewed
|
||||
detector.mark_reviewed(pr_number, head_sha)
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import datetime, timedelta
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
@dataclass
|
||||
class BotDetectionState:
|
||||
"""State for tracking reviewed PRs and commits."""
|
||||
|
||||
# PR number -> set of reviewed commit SHAs
|
||||
reviewed_commits: dict[int, list[str]] = field(default_factory=dict)
|
||||
|
||||
# PR number -> last review timestamp (ISO format)
|
||||
last_review_times: dict[int, str] = field(default_factory=dict)
|
||||
|
||||
def to_dict(self) -> dict:
|
||||
"""Convert to dictionary for JSON serialization."""
|
||||
return {
|
||||
"reviewed_commits": self.reviewed_commits,
|
||||
"last_review_times": self.last_review_times,
|
||||
}
|
||||
|
||||
@classmethod
|
||||
def from_dict(cls, data: dict) -> BotDetectionState:
|
||||
"""Load from dictionary."""
|
||||
return cls(
|
||||
reviewed_commits=data.get("reviewed_commits", {}),
|
||||
last_review_times=data.get("last_review_times", {}),
|
||||
)
|
||||
|
||||
def save(self, state_dir: Path) -> None:
|
||||
"""Save state to disk."""
|
||||
state_dir.mkdir(parents=True, exist_ok=True)
|
||||
state_file = state_dir / "bot_detection_state.json"
|
||||
|
||||
with open(state_file, "w") as f:
|
||||
json.dump(self.to_dict(), f, indent=2)
|
||||
|
||||
@classmethod
|
||||
def load(cls, state_dir: Path) -> BotDetectionState:
|
||||
"""Load state from disk."""
|
||||
state_file = state_dir / "bot_detection_state.json"
|
||||
|
||||
if not state_file.exists():
|
||||
return cls()
|
||||
|
||||
with open(state_file) as f:
|
||||
return cls.from_dict(json.load(f))
|
||||
|
||||
|
||||
class BotDetector:
|
||||
"""
|
||||
Detects bot-authored PRs and commits to prevent infinite review loops.
|
||||
|
||||
Configuration via GitHubRunnerConfig:
|
||||
- review_own_prs: bool = False (whether bot can review its own PRs)
|
||||
- bot_token: str | None (separate bot account token)
|
||||
|
||||
Automatic safeguards:
|
||||
- 1-minute cooling off period between reviews of same PR (for testing)
|
||||
- Tracks reviewed commit SHAs to avoid duplicate reviews
|
||||
- Identifies bot user from token to skip bot-authored content
|
||||
"""
|
||||
|
||||
# Cooling off period in minutes (reduced to 1 for testing large PRs)
|
||||
COOLING_OFF_MINUTES = 1
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
state_dir: Path,
|
||||
bot_token: str | None = None,
|
||||
review_own_prs: bool = False,
|
||||
):
|
||||
"""
|
||||
Initialize bot detector.
|
||||
|
||||
Args:
|
||||
state_dir: Directory for storing detection state
|
||||
bot_token: GitHub token for bot (to identify bot user)
|
||||
review_own_prs: Whether to allow reviewing bot's own PRs
|
||||
"""
|
||||
self.state_dir = state_dir
|
||||
self.bot_token = bot_token
|
||||
self.review_own_prs = review_own_prs
|
||||
|
||||
# Load or initialize state
|
||||
self.state = BotDetectionState.load(state_dir)
|
||||
|
||||
# Identify bot username from token
|
||||
self.bot_username = self._get_bot_username()
|
||||
|
||||
print(
|
||||
f"[BotDetector] Initialized: bot_user={self.bot_username}, review_own_prs={review_own_prs}",
|
||||
file=sys.stderr,
|
||||
)
|
||||
|
||||
def _get_bot_username(self) -> str | None:
|
||||
"""
|
||||
Get the bot's GitHub username from the token.
|
||||
|
||||
Returns:
|
||||
Bot username or None if token not provided or invalid
|
||||
"""
|
||||
if not self.bot_token:
|
||||
print(
|
||||
"[BotDetector] No bot token provided, cannot identify bot user",
|
||||
file=sys.stderr,
|
||||
)
|
||||
return None
|
||||
|
||||
try:
|
||||
# Use gh api to get authenticated user
|
||||
# Pass token via environment variable to avoid exposing it in process listings
|
||||
env = os.environ.copy()
|
||||
env["GH_TOKEN"] = self.bot_token
|
||||
result = subprocess.run(
|
||||
[
|
||||
"gh",
|
||||
"api",
|
||||
"user",
|
||||
],
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=5,
|
||||
env=env,
|
||||
)
|
||||
|
||||
if result.returncode == 0:
|
||||
user_data = json.loads(result.stdout)
|
||||
username = user_data.get("login")
|
||||
print(f"[BotDetector] Identified bot user: {username}")
|
||||
return username
|
||||
else:
|
||||
print(f"[BotDetector] Failed to identify bot user: {result.stderr}")
|
||||
return None
|
||||
|
||||
except Exception as e:
|
||||
print(f"[BotDetector] Error identifying bot user: {e}")
|
||||
return None
|
||||
|
||||
def is_bot_pr(self, pr_data: dict) -> bool:
|
||||
"""
|
||||
Check if PR was created by the bot.
|
||||
|
||||
Args:
|
||||
pr_data: PR data from GitHub API (must have 'author' field)
|
||||
|
||||
Returns:
|
||||
True if PR author matches bot username
|
||||
"""
|
||||
if not self.bot_username:
|
||||
return False
|
||||
|
||||
pr_author = pr_data.get("author", {}).get("login")
|
||||
is_bot = pr_author == self.bot_username
|
||||
|
||||
if is_bot:
|
||||
print(f"[BotDetector] PR is bot-authored: {pr_author}")
|
||||
|
||||
return is_bot
|
||||
|
||||
def is_bot_commit(self, commit_data: dict) -> bool:
|
||||
"""
|
||||
Check if commit was authored by the bot.
|
||||
|
||||
Args:
|
||||
commit_data: Commit data from GitHub API (must have 'author' field)
|
||||
|
||||
Returns:
|
||||
True if commit author matches bot username
|
||||
"""
|
||||
if not self.bot_username:
|
||||
return False
|
||||
|
||||
# Check both author and committer (could be different)
|
||||
commit_author = commit_data.get("author", {}).get("login")
|
||||
commit_committer = commit_data.get("committer", {}).get("login")
|
||||
|
||||
is_bot = (
|
||||
commit_author == self.bot_username or commit_committer == self.bot_username
|
||||
)
|
||||
|
||||
if is_bot:
|
||||
print(
|
||||
f"[BotDetector] Commit is bot-authored: {commit_author or commit_committer}"
|
||||
)
|
||||
|
||||
return is_bot
|
||||
|
||||
def get_last_commit_sha(self, commits: list[dict]) -> str | None:
|
||||
"""
|
||||
Get the SHA of the most recent commit.
|
||||
|
||||
Args:
|
||||
commits: List of commit data from GitHub API
|
||||
|
||||
Returns:
|
||||
SHA of latest commit or None if no commits
|
||||
"""
|
||||
if not commits:
|
||||
return None
|
||||
|
||||
# GitHub API returns commits in chronological order (oldest first, newest last)
|
||||
latest = commits[-1]
|
||||
return latest.get("oid") or latest.get("sha")
|
||||
|
||||
def is_within_cooling_off(self, pr_number: int) -> tuple[bool, str]:
|
||||
"""
|
||||
Check if PR is within cooling off period.
|
||||
|
||||
Args:
|
||||
pr_number: The PR number
|
||||
|
||||
Returns:
|
||||
Tuple of (is_cooling_off, reason_message)
|
||||
"""
|
||||
last_review_str = self.state.last_review_times.get(str(pr_number))
|
||||
|
||||
if not last_review_str:
|
||||
return False, ""
|
||||
|
||||
try:
|
||||
last_review = datetime.fromisoformat(last_review_str)
|
||||
time_since = datetime.now() - last_review
|
||||
|
||||
if time_since < timedelta(minutes=self.COOLING_OFF_MINUTES):
|
||||
minutes_left = self.COOLING_OFF_MINUTES - (
|
||||
time_since.total_seconds() / 60
|
||||
)
|
||||
reason = (
|
||||
f"Cooling off period active (reviewed {int(time_since.total_seconds() / 60)}m ago, "
|
||||
f"{int(minutes_left)}m remaining)"
|
||||
)
|
||||
print(f"[BotDetector] PR #{pr_number}: {reason}")
|
||||
return True, reason
|
||||
|
||||
except (ValueError, TypeError) as e:
|
||||
print(f"[BotDetector] Error parsing last review time: {e}")
|
||||
|
||||
return False, ""
|
||||
|
||||
def has_reviewed_commit(self, pr_number: int, commit_sha: str) -> bool:
|
||||
"""
|
||||
Check if we've already reviewed this specific commit.
|
||||
|
||||
Args:
|
||||
pr_number: The PR number
|
||||
commit_sha: The commit SHA to check
|
||||
|
||||
Returns:
|
||||
True if this commit was already reviewed
|
||||
"""
|
||||
reviewed = self.state.reviewed_commits.get(str(pr_number), [])
|
||||
return commit_sha in reviewed
|
||||
|
||||
def should_skip_pr_review(
|
||||
self,
|
||||
pr_number: int,
|
||||
pr_data: dict,
|
||||
commits: list[dict] | None = None,
|
||||
) -> tuple[bool, str]:
|
||||
"""
|
||||
Determine if we should skip reviewing this PR.
|
||||
|
||||
This is the main entry point for bot detection logic.
|
||||
|
||||
Args:
|
||||
pr_number: The PR number
|
||||
pr_data: PR data from GitHub API
|
||||
commits: Optional list of commits in the PR
|
||||
|
||||
Returns:
|
||||
Tuple of (should_skip, reason)
|
||||
"""
|
||||
# Check 1: Is this a bot-authored PR?
|
||||
if not self.review_own_prs and self.is_bot_pr(pr_data):
|
||||
reason = f"PR authored by bot user ({self.bot_username})"
|
||||
print(f"[BotDetector] SKIP PR #{pr_number}: {reason}")
|
||||
return True, reason
|
||||
|
||||
# Check 2: Is the latest commit by the bot?
|
||||
if commits and not self.review_own_prs:
|
||||
latest_commit = commits[0] if commits else None
|
||||
if latest_commit and self.is_bot_commit(latest_commit):
|
||||
reason = "Latest commit authored by bot (likely an auto-fix)"
|
||||
print(f"[BotDetector] SKIP PR #{pr_number}: {reason}")
|
||||
return True, reason
|
||||
|
||||
# Check 3: Are we in the cooling off period?
|
||||
is_cooling, reason = self.is_within_cooling_off(pr_number)
|
||||
if is_cooling:
|
||||
print(f"[BotDetector] SKIP PR #{pr_number}: {reason}")
|
||||
return True, reason
|
||||
|
||||
# Check 4: Have we already reviewed this exact commit?
|
||||
head_sha = self.get_last_commit_sha(commits) if commits else None
|
||||
if head_sha and self.has_reviewed_commit(pr_number, head_sha):
|
||||
reason = f"Already reviewed commit {head_sha[:8]}"
|
||||
print(f"[BotDetector] SKIP PR #{pr_number}: {reason}")
|
||||
return True, reason
|
||||
|
||||
# All checks passed - safe to review
|
||||
print(f"[BotDetector] PR #{pr_number} is safe to review")
|
||||
return False, ""
|
||||
|
||||
def mark_reviewed(self, pr_number: int, commit_sha: str) -> None:
|
||||
"""
|
||||
Mark a PR as reviewed at a specific commit.
|
||||
|
||||
This should be called after successfully posting a review.
|
||||
|
||||
Args:
|
||||
pr_number: The PR number
|
||||
commit_sha: The commit SHA that was reviewed
|
||||
"""
|
||||
pr_key = str(pr_number)
|
||||
|
||||
# Add to reviewed commits
|
||||
if pr_key not in self.state.reviewed_commits:
|
||||
self.state.reviewed_commits[pr_key] = []
|
||||
|
||||
if commit_sha not in self.state.reviewed_commits[pr_key]:
|
||||
self.state.reviewed_commits[pr_key].append(commit_sha)
|
||||
|
||||
# Update last review time
|
||||
self.state.last_review_times[pr_key] = datetime.now().isoformat()
|
||||
|
||||
# Save state
|
||||
self.state.save(self.state_dir)
|
||||
|
||||
print(
|
||||
f"[BotDetector] Marked PR #{pr_number} as reviewed at {commit_sha[:8]} "
|
||||
f"({len(self.state.reviewed_commits[pr_key])} total commits reviewed)"
|
||||
)
|
||||
|
||||
def clear_pr_state(self, pr_number: int) -> None:
|
||||
"""
|
||||
Clear tracking state for a PR (e.g., when PR is closed/merged).
|
||||
|
||||
Args:
|
||||
pr_number: The PR number
|
||||
"""
|
||||
pr_key = str(pr_number)
|
||||
|
||||
if pr_key in self.state.reviewed_commits:
|
||||
del self.state.reviewed_commits[pr_key]
|
||||
|
||||
if pr_key in self.state.last_review_times:
|
||||
del self.state.last_review_times[pr_key]
|
||||
|
||||
self.state.save(self.state_dir)
|
||||
|
||||
print(f"[BotDetector] Cleared state for PR #{pr_number}")
|
||||
|
||||
def get_stats(self) -> dict:
|
||||
"""
|
||||
Get statistics about bot detection activity.
|
||||
|
||||
Returns:
|
||||
Dictionary with stats
|
||||
"""
|
||||
total_prs = len(self.state.reviewed_commits)
|
||||
total_reviews = sum(
|
||||
len(commits) for commits in self.state.reviewed_commits.values()
|
||||
)
|
||||
|
||||
return {
|
||||
"bot_username": self.bot_username,
|
||||
"review_own_prs": self.review_own_prs,
|
||||
"total_prs_tracked": total_prs,
|
||||
"total_reviews_performed": total_reviews,
|
||||
"cooling_off_minutes": self.COOLING_OFF_MINUTES,
|
||||
}
|
||||
@@ -1,154 +0,0 @@
|
||||
"""
|
||||
Bot Detection Integration Example
|
||||
==================================
|
||||
|
||||
Demonstrates how to use the bot detection system to prevent infinite loops.
|
||||
"""
|
||||
|
||||
from pathlib import Path
|
||||
|
||||
from models import GitHubRunnerConfig
|
||||
from orchestrator import GitHubOrchestrator
|
||||
|
||||
|
||||
async def example_with_bot_detection():
|
||||
"""Example: Reviewing PRs with bot detection enabled."""
|
||||
|
||||
# Create config with bot detection
|
||||
config = GitHubRunnerConfig(
|
||||
token="ghp_user_token",
|
||||
repo="owner/repo",
|
||||
bot_token="ghp_bot_token", # Bot's token for self-identification
|
||||
pr_review_enabled=True,
|
||||
auto_post_reviews=False, # Manual review posting for this example
|
||||
review_own_prs=False, # CRITICAL: Prevent reviewing own PRs
|
||||
)
|
||||
|
||||
# Initialize orchestrator (bot detector is auto-initialized)
|
||||
orchestrator = GitHubOrchestrator(
|
||||
project_dir=Path("/path/to/project"),
|
||||
config=config,
|
||||
)
|
||||
|
||||
print(f"Bot username: {orchestrator.bot_detector.bot_username}")
|
||||
print(f"Review own PRs: {orchestrator.bot_detector.review_own_prs}")
|
||||
print(
|
||||
f"Cooling off period: {orchestrator.bot_detector.COOLING_OFF_MINUTES} minutes"
|
||||
)
|
||||
print()
|
||||
|
||||
# Scenario 1: Review a human-authored PR
|
||||
print("=== Scenario 1: Human PR ===")
|
||||
result = await orchestrator.review_pr(pr_number=123)
|
||||
print(f"Result: {result.summary}")
|
||||
print(f"Findings: {len(result.findings)}")
|
||||
print()
|
||||
|
||||
# Scenario 2: Try to review immediately again (cooling off)
|
||||
print("=== Scenario 2: Immediate re-review (should skip) ===")
|
||||
result = await orchestrator.review_pr(pr_number=123)
|
||||
print(f"Result: {result.summary}")
|
||||
print()
|
||||
|
||||
# Scenario 3: Review bot-authored PR (should skip)
|
||||
print("=== Scenario 3: Bot-authored PR (should skip) ===")
|
||||
result = await orchestrator.review_pr(pr_number=456) # Assume this is bot's PR
|
||||
print(f"Result: {result.summary}")
|
||||
print()
|
||||
|
||||
# Check statistics
|
||||
stats = orchestrator.bot_detector.get_stats()
|
||||
print("=== Bot Detection Statistics ===")
|
||||
print(f"Bot username: {stats['bot_username']}")
|
||||
print(f"Total PRs tracked: {stats['total_prs_tracked']}")
|
||||
print(f"Total reviews: {stats['total_reviews_performed']}")
|
||||
|
||||
|
||||
async def example_manual_state_management():
|
||||
"""Example: Manually managing bot detection state."""
|
||||
|
||||
config = GitHubRunnerConfig(
|
||||
token="ghp_user_token",
|
||||
repo="owner/repo",
|
||||
bot_token="ghp_bot_token",
|
||||
review_own_prs=False,
|
||||
)
|
||||
|
||||
orchestrator = GitHubOrchestrator(
|
||||
project_dir=Path("/path/to/project"),
|
||||
config=config,
|
||||
)
|
||||
|
||||
detector = orchestrator.bot_detector
|
||||
|
||||
# Manually check if PR should be skipped
|
||||
pr_data = {"author": {"login": "alice"}}
|
||||
commits = [
|
||||
{"author": {"login": "alice"}, "oid": "abc123"},
|
||||
{"author": {"login": "alice"}, "oid": "def456"},
|
||||
]
|
||||
|
||||
should_skip, reason = detector.should_skip_pr_review(
|
||||
pr_number=789,
|
||||
pr_data=pr_data,
|
||||
commits=commits,
|
||||
)
|
||||
|
||||
if should_skip:
|
||||
print(f"Skipping PR #789: {reason}")
|
||||
else:
|
||||
print("PR #789 is safe to review")
|
||||
# Proceed with review...
|
||||
# After review:
|
||||
detector.mark_reviewed(789, "abc123")
|
||||
|
||||
# Clear state when PR is closed/merged
|
||||
detector.clear_pr_state(789)
|
||||
|
||||
|
||||
def example_configuration_options():
|
||||
"""Example: Different configuration scenarios."""
|
||||
|
||||
# Option 1: Strict bot detection (recommended)
|
||||
strict_config = GitHubRunnerConfig(
|
||||
token="ghp_user_token",
|
||||
repo="owner/repo",
|
||||
bot_token="ghp_bot_token",
|
||||
review_own_prs=False, # Bot cannot review own PRs
|
||||
)
|
||||
|
||||
# Option 2: Allow bot self-review (testing only)
|
||||
permissive_config = GitHubRunnerConfig(
|
||||
token="ghp_user_token",
|
||||
repo="owner/repo",
|
||||
bot_token="ghp_bot_token",
|
||||
review_own_prs=True, # Bot CAN review own PRs
|
||||
)
|
||||
|
||||
# Option 3: No bot detection (no bot token)
|
||||
no_detection_config = GitHubRunnerConfig(
|
||||
token="ghp_user_token",
|
||||
repo="owner/repo",
|
||||
bot_token=None, # No bot identification
|
||||
review_own_prs=False,
|
||||
)
|
||||
|
||||
print("Strict config:", strict_config.review_own_prs)
|
||||
print("Permissive config:", permissive_config.review_own_prs)
|
||||
print("No detection config:", no_detection_config.bot_token)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
print("Bot Detection Integration Examples\n")
|
||||
|
||||
print("\n1. Configuration Options")
|
||||
print("=" * 50)
|
||||
example_configuration_options()
|
||||
|
||||
print("\n2. With Bot Detection (requires GitHub setup)")
|
||||
print("=" * 50)
|
||||
print("Run: asyncio.run(example_with_bot_detection())")
|
||||
|
||||
print("\n3. Manual State Management")
|
||||
print("=" * 50)
|
||||
print("Run: asyncio.run(example_manual_state_management())")
|
||||
@@ -1,510 +0,0 @@
|
||||
"""
|
||||
Data Retention & Cleanup
|
||||
========================
|
||||
|
||||
Manages data retention, archival, and cleanup for the GitHub automation system.
|
||||
|
||||
Features:
|
||||
- Configurable retention periods by state
|
||||
- Automatic archival of old records
|
||||
- Index pruning on startup
|
||||
- GDPR-compliant deletion (full purge)
|
||||
- Storage usage metrics
|
||||
|
||||
Usage:
|
||||
cleaner = DataCleaner(state_dir=Path(".auto-claude/github"))
|
||||
|
||||
# Run automatic cleanup
|
||||
result = await cleaner.run_cleanup()
|
||||
print(f"Cleaned {result.deleted_count} records")
|
||||
|
||||
# Purge specific issue/PR data
|
||||
await cleaner.purge_issue(123)
|
||||
|
||||
# Get storage metrics
|
||||
metrics = cleaner.get_storage_metrics()
|
||||
|
||||
CLI:
|
||||
python runner.py cleanup --older-than 90d
|
||||
python runner.py cleanup --purge-issue 123
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from enum import Enum
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
from .purge_strategy import PurgeResult, PurgeStrategy
|
||||
from .storage_metrics import StorageMetrics, StorageMetricsCalculator
|
||||
|
||||
|
||||
class RetentionPolicy(str, Enum):
|
||||
"""Retention policies for different record types."""
|
||||
|
||||
COMPLETED = "completed" # 90 days
|
||||
FAILED = "failed" # 30 days
|
||||
CANCELLED = "cancelled" # 7 days
|
||||
STALE = "stale" # 14 days
|
||||
ARCHIVED = "archived" # Indefinite (moved to archive)
|
||||
|
||||
|
||||
# Default retention periods in days
|
||||
DEFAULT_RETENTION = {
|
||||
RetentionPolicy.COMPLETED: 90,
|
||||
RetentionPolicy.FAILED: 30,
|
||||
RetentionPolicy.CANCELLED: 7,
|
||||
RetentionPolicy.STALE: 14,
|
||||
}
|
||||
|
||||
|
||||
@dataclass
|
||||
class RetentionConfig:
|
||||
"""
|
||||
Configuration for data retention.
|
||||
"""
|
||||
|
||||
completed_days: int = 90
|
||||
failed_days: int = 30
|
||||
cancelled_days: int = 7
|
||||
stale_days: int = 14
|
||||
archive_enabled: bool = True
|
||||
gdpr_mode: bool = False # If True, deletes instead of archives
|
||||
|
||||
def get_retention_days(self, policy: RetentionPolicy) -> int:
|
||||
mapping = {
|
||||
RetentionPolicy.COMPLETED: self.completed_days,
|
||||
RetentionPolicy.FAILED: self.failed_days,
|
||||
RetentionPolicy.CANCELLED: self.cancelled_days,
|
||||
RetentionPolicy.STALE: self.stale_days,
|
||||
RetentionPolicy.ARCHIVED: -1, # Never auto-delete
|
||||
}
|
||||
return mapping.get(policy, 90)
|
||||
|
||||
def to_dict(self) -> dict[str, Any]:
|
||||
return {
|
||||
"completed_days": self.completed_days,
|
||||
"failed_days": self.failed_days,
|
||||
"cancelled_days": self.cancelled_days,
|
||||
"stale_days": self.stale_days,
|
||||
"archive_enabled": self.archive_enabled,
|
||||
"gdpr_mode": self.gdpr_mode,
|
||||
}
|
||||
|
||||
@classmethod
|
||||
def from_dict(cls, data: dict[str, Any]) -> RetentionConfig:
|
||||
return cls(**{k: v for k, v in data.items() if k in cls.__dataclass_fields__})
|
||||
|
||||
|
||||
@dataclass
|
||||
class CleanupResult:
|
||||
"""
|
||||
Result of a cleanup operation.
|
||||
"""
|
||||
|
||||
deleted_count: int = 0
|
||||
archived_count: int = 0
|
||||
pruned_index_entries: int = 0
|
||||
freed_bytes: int = 0
|
||||
errors: list[str] = field(default_factory=list)
|
||||
started_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
|
||||
completed_at: datetime | None = None
|
||||
dry_run: bool = False
|
||||
|
||||
@property
|
||||
def duration(self) -> timedelta | None:
|
||||
if self.completed_at:
|
||||
return self.completed_at - self.started_at
|
||||
return None
|
||||
|
||||
@property
|
||||
def freed_mb(self) -> float:
|
||||
return self.freed_bytes / (1024 * 1024)
|
||||
|
||||
def to_dict(self) -> dict[str, Any]:
|
||||
return {
|
||||
"deleted_count": self.deleted_count,
|
||||
"archived_count": self.archived_count,
|
||||
"pruned_index_entries": self.pruned_index_entries,
|
||||
"freed_bytes": self.freed_bytes,
|
||||
"freed_mb": round(self.freed_mb, 2),
|
||||
"errors": self.errors,
|
||||
"started_at": self.started_at.isoformat(),
|
||||
"completed_at": self.completed_at.isoformat()
|
||||
if self.completed_at
|
||||
else None,
|
||||
"duration_seconds": self.duration.total_seconds()
|
||||
if self.duration
|
||||
else None,
|
||||
"dry_run": self.dry_run,
|
||||
}
|
||||
|
||||
|
||||
# StorageMetrics is now imported from storage_metrics.py
|
||||
|
||||
|
||||
class DataCleaner:
|
||||
"""
|
||||
Manages data retention and cleanup.
|
||||
|
||||
Usage:
|
||||
cleaner = DataCleaner(state_dir=Path(".auto-claude/github"))
|
||||
|
||||
# Check what would be cleaned
|
||||
result = await cleaner.run_cleanup(dry_run=True)
|
||||
|
||||
# Actually clean
|
||||
result = await cleaner.run_cleanup()
|
||||
|
||||
# Purge specific data (GDPR)
|
||||
await cleaner.purge_issue(123)
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
state_dir: Path,
|
||||
config: RetentionConfig | None = None,
|
||||
):
|
||||
"""
|
||||
Initialize data cleaner.
|
||||
|
||||
Args:
|
||||
state_dir: Directory containing state files
|
||||
config: Retention configuration
|
||||
"""
|
||||
self.state_dir = state_dir
|
||||
self.config = config or RetentionConfig()
|
||||
self.archive_dir = state_dir / "archive"
|
||||
self._storage_calculator = StorageMetricsCalculator(state_dir)
|
||||
self._purge_strategy = PurgeStrategy(state_dir)
|
||||
|
||||
def get_storage_metrics(self) -> StorageMetrics:
|
||||
"""
|
||||
Get current storage usage metrics.
|
||||
|
||||
Returns:
|
||||
StorageMetrics with breakdown
|
||||
"""
|
||||
return self._storage_calculator.calculate()
|
||||
|
||||
async def run_cleanup(
|
||||
self,
|
||||
dry_run: bool = False,
|
||||
older_than_days: int | None = None,
|
||||
) -> CleanupResult:
|
||||
"""
|
||||
Run cleanup based on retention policy.
|
||||
|
||||
Args:
|
||||
dry_run: If True, only report what would be cleaned
|
||||
older_than_days: Override retention days for all types
|
||||
|
||||
Returns:
|
||||
CleanupResult with statistics
|
||||
"""
|
||||
result = CleanupResult(dry_run=dry_run)
|
||||
now = datetime.now(timezone.utc)
|
||||
|
||||
# Directories to clean
|
||||
directories = [
|
||||
(self.state_dir / "pr", "pr_reviews"),
|
||||
(self.state_dir / "issues", "issues"),
|
||||
(self.state_dir / "autofix", "autofix"),
|
||||
]
|
||||
|
||||
for dir_path, dir_type in directories:
|
||||
if not dir_path.exists():
|
||||
continue
|
||||
|
||||
for file_path in dir_path.glob("*.json"):
|
||||
try:
|
||||
cleaned = await self._process_file(
|
||||
file_path, now, older_than_days, dry_run, result
|
||||
)
|
||||
if cleaned:
|
||||
result.deleted_count += 1
|
||||
except Exception as e:
|
||||
result.errors.append(f"Error processing {file_path}: {e}")
|
||||
|
||||
# Prune indexes
|
||||
await self._prune_indexes(dry_run, result)
|
||||
|
||||
# Clean up audit logs
|
||||
await self._clean_audit_logs(now, older_than_days, dry_run, result)
|
||||
|
||||
result.completed_at = datetime.now(timezone.utc)
|
||||
return result
|
||||
|
||||
async def _process_file(
|
||||
self,
|
||||
file_path: Path,
|
||||
now: datetime,
|
||||
older_than_days: int | None,
|
||||
dry_run: bool,
|
||||
result: CleanupResult,
|
||||
) -> bool:
|
||||
"""Process a single file for cleanup."""
|
||||
try:
|
||||
with open(file_path) as f:
|
||||
data = json.load(f)
|
||||
except (OSError, json.JSONDecodeError):
|
||||
# Corrupted file, mark for deletion
|
||||
if not dry_run:
|
||||
file_size = file_path.stat().st_size
|
||||
file_path.unlink()
|
||||
result.freed_bytes += file_size
|
||||
return True
|
||||
|
||||
# Get status and timestamp
|
||||
status = data.get("status", "completed").lower()
|
||||
updated_at = data.get("updated_at") or data.get("created_at")
|
||||
|
||||
if not updated_at:
|
||||
return False
|
||||
|
||||
try:
|
||||
record_time = datetime.fromisoformat(updated_at.replace("Z", "+00:00"))
|
||||
except ValueError:
|
||||
return False
|
||||
|
||||
# Determine retention policy
|
||||
policy = self._get_policy_for_status(status)
|
||||
retention_days = older_than_days or self.config.get_retention_days(policy)
|
||||
|
||||
if retention_days < 0:
|
||||
return False # Never delete
|
||||
|
||||
cutoff = now - timedelta(days=retention_days)
|
||||
|
||||
if record_time < cutoff:
|
||||
file_size = file_path.stat().st_size
|
||||
|
||||
if not dry_run:
|
||||
if self.config.archive_enabled and not self.config.gdpr_mode:
|
||||
# Archive instead of delete
|
||||
await self._archive_file(file_path, data)
|
||||
result.archived_count += 1
|
||||
else:
|
||||
# Delete
|
||||
file_path.unlink()
|
||||
|
||||
result.freed_bytes += file_size
|
||||
|
||||
return True
|
||||
|
||||
return False
|
||||
|
||||
def _get_policy_for_status(self, status: str) -> RetentionPolicy:
|
||||
"""Map status to retention policy."""
|
||||
status_map = {
|
||||
"completed": RetentionPolicy.COMPLETED,
|
||||
"merged": RetentionPolicy.COMPLETED,
|
||||
"closed": RetentionPolicy.COMPLETED,
|
||||
"failed": RetentionPolicy.FAILED,
|
||||
"error": RetentionPolicy.FAILED,
|
||||
"cancelled": RetentionPolicy.CANCELLED,
|
||||
"stale": RetentionPolicy.STALE,
|
||||
"abandoned": RetentionPolicy.STALE,
|
||||
}
|
||||
return status_map.get(status, RetentionPolicy.COMPLETED)
|
||||
|
||||
async def _archive_file(
|
||||
self,
|
||||
file_path: Path,
|
||||
data: dict[str, Any],
|
||||
) -> None:
|
||||
"""Archive a file instead of deleting."""
|
||||
# Create archive directory structure
|
||||
relative = file_path.relative_to(self.state_dir)
|
||||
archive_path = self.archive_dir / relative
|
||||
|
||||
archive_path.parent.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
# Add archive metadata
|
||||
data["_archived_at"] = datetime.now(timezone.utc).isoformat()
|
||||
data["_original_path"] = str(file_path)
|
||||
|
||||
with open(archive_path, "w") as f:
|
||||
json.dump(data, f, indent=2)
|
||||
|
||||
# Remove original
|
||||
file_path.unlink()
|
||||
|
||||
async def _prune_indexes(
|
||||
self,
|
||||
dry_run: bool,
|
||||
result: CleanupResult,
|
||||
) -> None:
|
||||
"""Prune stale entries from index files."""
|
||||
index_files = [
|
||||
self.state_dir / "pr" / "index.json",
|
||||
self.state_dir / "issues" / "index.json",
|
||||
self.state_dir / "autofix" / "index.json",
|
||||
]
|
||||
|
||||
for index_path in index_files:
|
||||
if not index_path.exists():
|
||||
continue
|
||||
|
||||
try:
|
||||
with open(index_path) as f:
|
||||
index_data = json.load(f)
|
||||
|
||||
if not isinstance(index_data, dict):
|
||||
continue
|
||||
|
||||
items = index_data.get("items", {})
|
||||
if not isinstance(items, dict):
|
||||
continue
|
||||
|
||||
pruned = 0
|
||||
to_remove = []
|
||||
|
||||
for key, entry in items.items():
|
||||
# Check if referenced file exists
|
||||
file_path = entry.get("file_path") or entry.get("path")
|
||||
if file_path:
|
||||
if not Path(file_path).exists():
|
||||
to_remove.append(key)
|
||||
pruned += 1
|
||||
|
||||
if to_remove and not dry_run:
|
||||
for key in to_remove:
|
||||
del items[key]
|
||||
|
||||
with open(index_path, "w") as f:
|
||||
json.dump(index_data, f, indent=2)
|
||||
|
||||
result.pruned_index_entries += pruned
|
||||
|
||||
except (OSError, json.JSONDecodeError, KeyError):
|
||||
result.errors.append(f"Error pruning index: {index_path}")
|
||||
|
||||
async def _clean_audit_logs(
|
||||
self,
|
||||
now: datetime,
|
||||
older_than_days: int | None,
|
||||
dry_run: bool,
|
||||
result: CleanupResult,
|
||||
) -> None:
|
||||
"""Clean old audit logs."""
|
||||
audit_dir = self.state_dir / "audit"
|
||||
if not audit_dir.exists():
|
||||
return
|
||||
|
||||
# Default 30 day retention for audit logs (overridable)
|
||||
retention_days = older_than_days or 30
|
||||
cutoff = now - timedelta(days=retention_days)
|
||||
|
||||
for log_file in audit_dir.glob("*.log"):
|
||||
try:
|
||||
# Check file modification time
|
||||
mtime = datetime.fromtimestamp(
|
||||
log_file.stat().st_mtime, tz=timezone.utc
|
||||
)
|
||||
if mtime < cutoff:
|
||||
file_size = log_file.stat().st_size
|
||||
if not dry_run:
|
||||
log_file.unlink()
|
||||
result.freed_bytes += file_size
|
||||
result.deleted_count += 1
|
||||
except OSError as e:
|
||||
result.errors.append(f"Error cleaning audit log {log_file}: {e}")
|
||||
|
||||
async def purge_issue(
|
||||
self,
|
||||
issue_number: int,
|
||||
repo: str | None = None,
|
||||
) -> CleanupResult:
|
||||
"""
|
||||
Purge all data for a specific issue (GDPR-compliant).
|
||||
|
||||
Args:
|
||||
issue_number: Issue number to purge
|
||||
repo: Optional repository filter
|
||||
|
||||
Returns:
|
||||
CleanupResult
|
||||
"""
|
||||
purge_result = await self._purge_strategy.purge_by_criteria(
|
||||
pattern="issue",
|
||||
key="issue_number",
|
||||
value=issue_number,
|
||||
repo=repo,
|
||||
)
|
||||
|
||||
# Convert PurgeResult to CleanupResult
|
||||
return self._convert_purge_result(purge_result)
|
||||
|
||||
async def purge_pr(
|
||||
self,
|
||||
pr_number: int,
|
||||
repo: str | None = None,
|
||||
) -> CleanupResult:
|
||||
"""
|
||||
Purge all data for a specific PR (GDPR-compliant).
|
||||
|
||||
Args:
|
||||
pr_number: PR number to purge
|
||||
repo: Optional repository filter
|
||||
|
||||
Returns:
|
||||
CleanupResult
|
||||
"""
|
||||
purge_result = await self._purge_strategy.purge_by_criteria(
|
||||
pattern="pr",
|
||||
key="pr_number",
|
||||
value=pr_number,
|
||||
repo=repo,
|
||||
)
|
||||
|
||||
# Convert PurgeResult to CleanupResult
|
||||
return self._convert_purge_result(purge_result)
|
||||
|
||||
async def purge_repo(self, repo: str) -> CleanupResult:
|
||||
"""
|
||||
Purge all data for a specific repository.
|
||||
|
||||
Args:
|
||||
repo: Repository in owner/repo format
|
||||
|
||||
Returns:
|
||||
CleanupResult
|
||||
"""
|
||||
purge_result = await self._purge_strategy.purge_repository(repo)
|
||||
|
||||
# Convert PurgeResult to CleanupResult
|
||||
return self._convert_purge_result(purge_result)
|
||||
|
||||
def _convert_purge_result(self, purge_result: PurgeResult) -> CleanupResult:
|
||||
"""
|
||||
Convert PurgeResult to CleanupResult.
|
||||
|
||||
Args:
|
||||
purge_result: PurgeResult from PurgeStrategy
|
||||
|
||||
Returns:
|
||||
CleanupResult for DataCleaner API compatibility
|
||||
"""
|
||||
cleanup_result = CleanupResult(
|
||||
deleted_count=purge_result.deleted_count,
|
||||
freed_bytes=purge_result.freed_bytes,
|
||||
errors=purge_result.errors,
|
||||
started_at=purge_result.started_at,
|
||||
completed_at=purge_result.completed_at,
|
||||
)
|
||||
return cleanup_result
|
||||
|
||||
def get_retention_summary(self) -> dict[str, Any]:
|
||||
"""Get summary of retention settings and usage."""
|
||||
metrics = self.get_storage_metrics()
|
||||
|
||||
return {
|
||||
"config": self.config.to_dict(),
|
||||
"storage": metrics.to_dict(),
|
||||
"archive_enabled": self.config.archive_enabled,
|
||||
"gdpr_mode": self.config.gdpr_mode,
|
||||
}
|
||||
@@ -1,562 +0,0 @@
|
||||
"""
|
||||
Review Confidence Scoring
|
||||
=========================
|
||||
|
||||
Adds confidence scores to review findings to help users prioritize.
|
||||
|
||||
Features:
|
||||
- Confidence scoring based on pattern matching, historical accuracy
|
||||
- Risk assessment (false positive likelihood)
|
||||
- Evidence tracking for transparency
|
||||
- Calibration based on outcome tracking
|
||||
|
||||
Usage:
|
||||
scorer = ConfidenceScorer(learning_tracker=tracker)
|
||||
|
||||
# Score a finding
|
||||
scored = scorer.score_finding(finding, context)
|
||||
print(f"Confidence: {scored.confidence}%")
|
||||
print(f"False positive risk: {scored.false_positive_risk}")
|
||||
|
||||
# Get explanation
|
||||
print(scorer.explain_confidence(scored))
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass, field
|
||||
from enum import Enum
|
||||
from typing import Any
|
||||
|
||||
# Import learning tracker if available
|
||||
try:
|
||||
from .learning import LearningPattern, LearningTracker
|
||||
except (ImportError, ValueError, SystemError):
|
||||
LearningTracker = None
|
||||
LearningPattern = None
|
||||
|
||||
|
||||
class FalsePositiveRisk(str, Enum):
|
||||
"""Likelihood that a finding is a false positive."""
|
||||
|
||||
LOW = "low" # <10% chance
|
||||
MEDIUM = "medium" # 10-30% chance
|
||||
HIGH = "high" # >30% chance
|
||||
UNKNOWN = "unknown"
|
||||
|
||||
|
||||
class ConfidenceLevel(str, Enum):
|
||||
"""Confidence level categories."""
|
||||
|
||||
VERY_HIGH = "very_high" # 90%+
|
||||
HIGH = "high" # 75-90%
|
||||
MEDIUM = "medium" # 50-75%
|
||||
LOW = "low" # <50%
|
||||
|
||||
|
||||
@dataclass
|
||||
class ConfidenceFactors:
|
||||
"""
|
||||
Factors that contribute to confidence score.
|
||||
"""
|
||||
|
||||
# Pattern-based factors
|
||||
pattern_matches: int = 0 # Similar patterns found
|
||||
pattern_accuracy: float = 0.0 # Historical accuracy of this pattern
|
||||
|
||||
# Context factors
|
||||
file_type_accuracy: float = 0.0 # Accuracy for this file type
|
||||
category_accuracy: float = 0.0 # Accuracy for this category
|
||||
|
||||
# Evidence factors
|
||||
code_evidence_count: int = 0 # Code references supporting finding
|
||||
similar_findings_count: int = 0 # Similar findings in codebase
|
||||
|
||||
# Historical factors
|
||||
historical_sample_size: int = 0 # How many similar cases we've seen
|
||||
historical_accuracy: float = 0.0 # Accuracy on similar cases
|
||||
|
||||
# Severity factors
|
||||
severity_weight: float = 1.0 # Higher severity = more scrutiny
|
||||
|
||||
def to_dict(self) -> dict[str, Any]:
|
||||
return {
|
||||
"pattern_matches": self.pattern_matches,
|
||||
"pattern_accuracy": self.pattern_accuracy,
|
||||
"file_type_accuracy": self.file_type_accuracy,
|
||||
"category_accuracy": self.category_accuracy,
|
||||
"code_evidence_count": self.code_evidence_count,
|
||||
"similar_findings_count": self.similar_findings_count,
|
||||
"historical_sample_size": self.historical_sample_size,
|
||||
"historical_accuracy": self.historical_accuracy,
|
||||
"severity_weight": self.severity_weight,
|
||||
}
|
||||
|
||||
|
||||
@dataclass
|
||||
class ScoredFinding:
|
||||
"""
|
||||
A finding with confidence scoring.
|
||||
"""
|
||||
|
||||
finding_id: str
|
||||
original_finding: dict[str, Any]
|
||||
|
||||
# Confidence score (0-100)
|
||||
confidence: float
|
||||
confidence_level: ConfidenceLevel
|
||||
|
||||
# False positive risk
|
||||
false_positive_risk: FalsePositiveRisk
|
||||
|
||||
# Factors that contributed
|
||||
factors: ConfidenceFactors
|
||||
|
||||
# Evidence for the finding
|
||||
evidence: list[str] = field(default_factory=list)
|
||||
|
||||
# Explanation basis
|
||||
explanation_basis: str = ""
|
||||
|
||||
@property
|
||||
def is_high_confidence(self) -> bool:
|
||||
return self.confidence >= 75.0
|
||||
|
||||
@property
|
||||
def should_highlight(self) -> bool:
|
||||
"""Should this finding be highlighted to the user?"""
|
||||
return (
|
||||
self.is_high_confidence
|
||||
and self.false_positive_risk != FalsePositiveRisk.HIGH
|
||||
)
|
||||
|
||||
def to_dict(self) -> dict[str, Any]:
|
||||
return {
|
||||
"finding_id": self.finding_id,
|
||||
"original_finding": self.original_finding,
|
||||
"confidence": self.confidence,
|
||||
"confidence_level": self.confidence_level.value,
|
||||
"false_positive_risk": self.false_positive_risk.value,
|
||||
"factors": self.factors.to_dict(),
|
||||
"evidence": self.evidence,
|
||||
"explanation_basis": self.explanation_basis,
|
||||
}
|
||||
|
||||
|
||||
@dataclass
|
||||
class ReviewContext:
|
||||
"""
|
||||
Context for scoring a review.
|
||||
"""
|
||||
|
||||
file_types: list[str] = field(default_factory=list)
|
||||
categories: list[str] = field(default_factory=list)
|
||||
change_size: str = "medium" # small/medium/large
|
||||
pr_author: str = ""
|
||||
is_external_contributor: bool = False
|
||||
|
||||
|
||||
class ConfidenceScorer:
|
||||
"""
|
||||
Scores confidence for review findings.
|
||||
|
||||
Uses historical data, pattern matching, and evidence to provide
|
||||
calibrated confidence scores.
|
||||
"""
|
||||
|
||||
# Base weights for different factors
|
||||
PATTERN_WEIGHT = 0.25
|
||||
HISTORY_WEIGHT = 0.30
|
||||
EVIDENCE_WEIGHT = 0.25
|
||||
CATEGORY_WEIGHT = 0.20
|
||||
|
||||
# Minimum sample size for reliable historical data
|
||||
MIN_SAMPLE_SIZE = 10
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
learning_tracker: Any | None = None,
|
||||
patterns: list[Any] | None = None,
|
||||
):
|
||||
"""
|
||||
Initialize confidence scorer.
|
||||
|
||||
Args:
|
||||
learning_tracker: LearningTracker for historical data
|
||||
patterns: Pre-computed patterns for scoring
|
||||
"""
|
||||
self.learning_tracker = learning_tracker
|
||||
self.patterns = patterns or []
|
||||
|
||||
def score_finding(
|
||||
self,
|
||||
finding: dict[str, Any],
|
||||
context: ReviewContext | None = None,
|
||||
) -> ScoredFinding:
|
||||
"""
|
||||
Score confidence for a single finding.
|
||||
|
||||
Args:
|
||||
finding: The finding to score
|
||||
context: Review context
|
||||
|
||||
Returns:
|
||||
ScoredFinding with confidence score
|
||||
"""
|
||||
context = context or ReviewContext()
|
||||
factors = ConfidenceFactors()
|
||||
|
||||
# Extract finding metadata
|
||||
finding_id = finding.get("id", str(hash(str(finding))))
|
||||
severity = finding.get("severity", "medium")
|
||||
category = finding.get("category", "")
|
||||
file_path = finding.get("file", "")
|
||||
evidence = finding.get("evidence", [])
|
||||
|
||||
# Set severity weight
|
||||
severity_weights = {
|
||||
"critical": 1.2,
|
||||
"high": 1.1,
|
||||
"medium": 1.0,
|
||||
"low": 0.9,
|
||||
"info": 0.8,
|
||||
}
|
||||
factors.severity_weight = severity_weights.get(severity.lower(), 1.0)
|
||||
|
||||
# Score based on evidence
|
||||
factors.code_evidence_count = len(evidence)
|
||||
evidence_score = min(1.0, len(evidence) * 0.2) # Up to 5 pieces = 100%
|
||||
|
||||
# Score based on patterns
|
||||
pattern_score = self._score_patterns(category, file_path, context, factors)
|
||||
|
||||
# Score based on historical accuracy
|
||||
history_score = self._score_history(category, context, factors)
|
||||
|
||||
# Score based on category
|
||||
category_score = self._score_category(category, factors)
|
||||
|
||||
# Calculate weighted confidence
|
||||
raw_confidence = (
|
||||
pattern_score * self.PATTERN_WEIGHT
|
||||
+ history_score * self.HISTORY_WEIGHT
|
||||
+ evidence_score * self.EVIDENCE_WEIGHT
|
||||
+ category_score * self.CATEGORY_WEIGHT
|
||||
)
|
||||
|
||||
# Apply severity weight
|
||||
raw_confidence *= factors.severity_weight
|
||||
|
||||
# Convert to 0-100 scale
|
||||
confidence = min(100.0, max(0.0, raw_confidence * 100))
|
||||
|
||||
# Determine confidence level
|
||||
if confidence >= 90:
|
||||
confidence_level = ConfidenceLevel.VERY_HIGH
|
||||
elif confidence >= 75:
|
||||
confidence_level = ConfidenceLevel.HIGH
|
||||
elif confidence >= 50:
|
||||
confidence_level = ConfidenceLevel.MEDIUM
|
||||
else:
|
||||
confidence_level = ConfidenceLevel.LOW
|
||||
|
||||
# Determine false positive risk
|
||||
false_positive_risk = self._assess_false_positive_risk(
|
||||
confidence, factors, context
|
||||
)
|
||||
|
||||
# Build explanation basis
|
||||
explanation_basis = self._build_explanation(factors, context)
|
||||
|
||||
return ScoredFinding(
|
||||
finding_id=finding_id,
|
||||
original_finding=finding,
|
||||
confidence=round(confidence, 1),
|
||||
confidence_level=confidence_level,
|
||||
false_positive_risk=false_positive_risk,
|
||||
factors=factors,
|
||||
evidence=evidence,
|
||||
explanation_basis=explanation_basis,
|
||||
)
|
||||
|
||||
def score_findings(
|
||||
self,
|
||||
findings: list[dict[str, Any]],
|
||||
context: ReviewContext | None = None,
|
||||
) -> list[ScoredFinding]:
|
||||
"""
|
||||
Score multiple findings.
|
||||
|
||||
Args:
|
||||
findings: List of findings
|
||||
context: Review context
|
||||
|
||||
Returns:
|
||||
List of scored findings, sorted by confidence
|
||||
"""
|
||||
scored = [self.score_finding(f, context) for f in findings]
|
||||
# Sort by confidence descending
|
||||
scored.sort(key=lambda s: s.confidence, reverse=True)
|
||||
return scored
|
||||
|
||||
def _score_patterns(
|
||||
self,
|
||||
category: str,
|
||||
file_path: str,
|
||||
context: ReviewContext,
|
||||
factors: ConfidenceFactors,
|
||||
) -> float:
|
||||
"""Score based on pattern matching."""
|
||||
if not self.patterns:
|
||||
return 0.5 # Neutral if no patterns
|
||||
|
||||
matches = 0
|
||||
total_accuracy = 0.0
|
||||
|
||||
# Get file extension
|
||||
file_ext = file_path.split(".")[-1] if "." in file_path else ""
|
||||
|
||||
for pattern in self.patterns:
|
||||
pattern_type = getattr(
|
||||
pattern, "pattern_type", pattern.get("pattern_type", "")
|
||||
)
|
||||
pattern_context = getattr(pattern, "context", pattern.get("context", {}))
|
||||
pattern_accuracy = getattr(
|
||||
pattern, "accuracy", pattern.get("accuracy", 0.5)
|
||||
)
|
||||
|
||||
# Check for file type match
|
||||
if pattern_type == "file_type_accuracy":
|
||||
if pattern_context.get("file_type") == file_ext:
|
||||
matches += 1
|
||||
total_accuracy += pattern_accuracy
|
||||
factors.file_type_accuracy = pattern_accuracy
|
||||
|
||||
# Check for category match
|
||||
if pattern_type == "category_accuracy":
|
||||
if pattern_context.get("category") == category:
|
||||
matches += 1
|
||||
total_accuracy += pattern_accuracy
|
||||
factors.category_accuracy = pattern_accuracy
|
||||
|
||||
factors.pattern_matches = matches
|
||||
|
||||
if matches > 0:
|
||||
factors.pattern_accuracy = total_accuracy / matches
|
||||
return factors.pattern_accuracy
|
||||
|
||||
return 0.5 # Neutral if no matches
|
||||
|
||||
def _score_history(
|
||||
self,
|
||||
category: str,
|
||||
context: ReviewContext,
|
||||
factors: ConfidenceFactors,
|
||||
) -> float:
|
||||
"""Score based on historical accuracy."""
|
||||
if not self.learning_tracker:
|
||||
return 0.5 # Neutral if no history
|
||||
|
||||
try:
|
||||
# Get accuracy stats
|
||||
stats = self.learning_tracker.get_accuracy()
|
||||
factors.historical_sample_size = stats.total_predictions
|
||||
|
||||
if stats.total_predictions >= self.MIN_SAMPLE_SIZE:
|
||||
factors.historical_accuracy = stats.accuracy
|
||||
return stats.accuracy
|
||||
else:
|
||||
# Not enough data, return neutral with penalty
|
||||
return 0.5 * (stats.total_predictions / self.MIN_SAMPLE_SIZE)
|
||||
|
||||
except Exception as e:
|
||||
# Log the error for debugging while returning neutral score
|
||||
import logging
|
||||
|
||||
logging.getLogger(__name__).warning(
|
||||
f"Error scoring history for category '{category}': {e}"
|
||||
)
|
||||
return 0.5
|
||||
|
||||
def _score_category(
|
||||
self,
|
||||
category: str,
|
||||
factors: ConfidenceFactors,
|
||||
) -> float:
|
||||
"""Score based on category reliability."""
|
||||
# Categories with higher inherent confidence
|
||||
high_confidence_categories = {
|
||||
"security": 0.85,
|
||||
"bug": 0.75,
|
||||
"error_handling": 0.70,
|
||||
"performance": 0.65,
|
||||
}
|
||||
|
||||
# Categories with lower inherent confidence
|
||||
low_confidence_categories = {
|
||||
"style": 0.50,
|
||||
"naming": 0.45,
|
||||
"documentation": 0.40,
|
||||
"nitpick": 0.35,
|
||||
}
|
||||
|
||||
if category.lower() in high_confidence_categories:
|
||||
return high_confidence_categories[category.lower()]
|
||||
elif category.lower() in low_confidence_categories:
|
||||
return low_confidence_categories[category.lower()]
|
||||
|
||||
return 0.6 # Default for unknown categories
|
||||
|
||||
def _assess_false_positive_risk(
|
||||
self,
|
||||
confidence: float,
|
||||
factors: ConfidenceFactors,
|
||||
context: ReviewContext,
|
||||
) -> FalsePositiveRisk:
|
||||
"""Assess risk of false positive."""
|
||||
# Low confidence = high false positive risk
|
||||
if confidence < 50:
|
||||
return FalsePositiveRisk.HIGH
|
||||
elif confidence < 75:
|
||||
# Check additional factors
|
||||
if factors.historical_sample_size < self.MIN_SAMPLE_SIZE:
|
||||
return FalsePositiveRisk.HIGH
|
||||
elif factors.historical_accuracy < 0.7:
|
||||
return FalsePositiveRisk.MEDIUM
|
||||
else:
|
||||
return FalsePositiveRisk.MEDIUM
|
||||
else:
|
||||
# High confidence
|
||||
if factors.code_evidence_count >= 3:
|
||||
return FalsePositiveRisk.LOW
|
||||
elif factors.historical_accuracy >= 0.85:
|
||||
return FalsePositiveRisk.LOW
|
||||
else:
|
||||
return FalsePositiveRisk.MEDIUM
|
||||
|
||||
def _build_explanation(
|
||||
self,
|
||||
factors: ConfidenceFactors,
|
||||
context: ReviewContext,
|
||||
) -> str:
|
||||
"""Build explanation for confidence score."""
|
||||
parts = []
|
||||
|
||||
if factors.historical_sample_size > 0:
|
||||
parts.append(
|
||||
f"Based on {factors.historical_sample_size} similar patterns "
|
||||
f"with {factors.historical_accuracy * 100:.0f}% accuracy"
|
||||
)
|
||||
|
||||
if factors.pattern_matches > 0:
|
||||
parts.append(f"Matched {factors.pattern_matches} known patterns")
|
||||
|
||||
if factors.code_evidence_count > 0:
|
||||
parts.append(f"Supported by {factors.code_evidence_count} code references")
|
||||
|
||||
if not parts:
|
||||
parts.append("Initial assessment without historical data")
|
||||
|
||||
return ". ".join(parts)
|
||||
|
||||
def explain_confidence(self, scored: ScoredFinding) -> str:
|
||||
"""
|
||||
Get a human-readable explanation of the confidence score.
|
||||
|
||||
Args:
|
||||
scored: The scored finding
|
||||
|
||||
Returns:
|
||||
Explanation string
|
||||
"""
|
||||
lines = [
|
||||
f"Confidence: {scored.confidence}% ({scored.confidence_level.value})",
|
||||
f"False positive risk: {scored.false_positive_risk.value}",
|
||||
"",
|
||||
"Basis:",
|
||||
f" {scored.explanation_basis}",
|
||||
]
|
||||
|
||||
if scored.factors.historical_sample_size > 0:
|
||||
lines.append(
|
||||
f" Historical accuracy: {scored.factors.historical_accuracy * 100:.0f}% "
|
||||
f"({scored.factors.historical_sample_size} samples)"
|
||||
)
|
||||
|
||||
if scored.evidence:
|
||||
lines.append(f" Evidence: {len(scored.evidence)} code references")
|
||||
|
||||
return "\n".join(lines)
|
||||
|
||||
def filter_by_confidence(
|
||||
self,
|
||||
scored_findings: list[ScoredFinding],
|
||||
min_confidence: float = 50.0,
|
||||
exclude_high_fp_risk: bool = False,
|
||||
) -> list[ScoredFinding]:
|
||||
"""
|
||||
Filter findings by confidence threshold.
|
||||
|
||||
Args:
|
||||
scored_findings: List of scored findings
|
||||
min_confidence: Minimum confidence to include
|
||||
exclude_high_fp_risk: Exclude high false positive risk
|
||||
|
||||
Returns:
|
||||
Filtered list
|
||||
"""
|
||||
result = []
|
||||
for finding in scored_findings:
|
||||
if finding.confidence < min_confidence:
|
||||
continue
|
||||
if (
|
||||
exclude_high_fp_risk
|
||||
and finding.false_positive_risk == FalsePositiveRisk.HIGH
|
||||
):
|
||||
continue
|
||||
result.append(finding)
|
||||
return result
|
||||
|
||||
def get_summary(
|
||||
self,
|
||||
scored_findings: list[ScoredFinding],
|
||||
) -> dict[str, Any]:
|
||||
"""
|
||||
Get summary statistics for scored findings.
|
||||
|
||||
Args:
|
||||
scored_findings: List of scored findings
|
||||
|
||||
Returns:
|
||||
Summary dict
|
||||
"""
|
||||
if not scored_findings:
|
||||
return {
|
||||
"total": 0,
|
||||
"avg_confidence": 0.0,
|
||||
"by_level": {},
|
||||
"by_risk": {},
|
||||
}
|
||||
|
||||
by_level: dict[str, int] = {}
|
||||
by_risk: dict[str, int] = {}
|
||||
total_confidence = 0.0
|
||||
|
||||
for finding in scored_findings:
|
||||
level = finding.confidence_level.value
|
||||
by_level[level] = by_level.get(level, 0) + 1
|
||||
|
||||
risk = finding.false_positive_risk.value
|
||||
by_risk[risk] = by_risk.get(risk, 0) + 1
|
||||
|
||||
total_confidence += finding.confidence
|
||||
|
||||
return {
|
||||
"total": len(scored_findings),
|
||||
"avg_confidence": total_confidence / len(scored_findings),
|
||||
"by_level": by_level,
|
||||
"by_risk": by_risk,
|
||||
"high_confidence_count": by_level.get("very_high", 0)
|
||||
+ by_level.get("high", 0),
|
||||
"low_risk_count": by_risk.get("low", 0),
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,601 +0,0 @@
|
||||
"""
|
||||
Semantic Duplicate Detection
|
||||
============================
|
||||
|
||||
Uses embeddings-based similarity to detect duplicate issues:
|
||||
- Replaces simple word overlap with semantic similarity
|
||||
- Integrates with OpenAI/Voyage AI embeddings
|
||||
- Caches embeddings with TTL
|
||||
- Extracts entities (error codes, file paths, function names)
|
||||
- Provides similarity breakdown by component
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
import logging
|
||||
import re
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
# Thresholds for duplicate detection
|
||||
DUPLICATE_THRESHOLD = 0.85 # Cosine similarity for "definitely duplicate"
|
||||
SIMILAR_THRESHOLD = 0.70 # Cosine similarity for "potentially related"
|
||||
EMBEDDING_CACHE_TTL_HOURS = 24
|
||||
|
||||
|
||||
@dataclass
|
||||
class EntityExtraction:
|
||||
"""Extracted entities from issue content."""
|
||||
|
||||
error_codes: list[str] = field(default_factory=list)
|
||||
file_paths: list[str] = field(default_factory=list)
|
||||
function_names: list[str] = field(default_factory=list)
|
||||
urls: list[str] = field(default_factory=list)
|
||||
stack_traces: list[str] = field(default_factory=list)
|
||||
versions: list[str] = field(default_factory=list)
|
||||
|
||||
def to_dict(self) -> dict[str, list[str]]:
|
||||
return {
|
||||
"error_codes": self.error_codes,
|
||||
"file_paths": self.file_paths,
|
||||
"function_names": self.function_names,
|
||||
"urls": self.urls,
|
||||
"stack_traces": self.stack_traces,
|
||||
"versions": self.versions,
|
||||
}
|
||||
|
||||
def overlap_with(self, other: EntityExtraction) -> dict[str, float]:
|
||||
"""Calculate overlap with another extraction."""
|
||||
|
||||
def jaccard(a: list, b: list) -> float:
|
||||
if not a and not b:
|
||||
return 0.0
|
||||
set_a, set_b = set(a), set(b)
|
||||
intersection = len(set_a & set_b)
|
||||
union = len(set_a | set_b)
|
||||
return intersection / union if union > 0 else 0.0
|
||||
|
||||
return {
|
||||
"error_codes": jaccard(self.error_codes, other.error_codes),
|
||||
"file_paths": jaccard(self.file_paths, other.file_paths),
|
||||
"function_names": jaccard(self.function_names, other.function_names),
|
||||
"urls": jaccard(self.urls, other.urls),
|
||||
}
|
||||
|
||||
|
||||
@dataclass
|
||||
class SimilarityResult:
|
||||
"""Result of similarity comparison between two issues."""
|
||||
|
||||
issue_a: int
|
||||
issue_b: int
|
||||
overall_score: float
|
||||
title_score: float
|
||||
body_score: float
|
||||
entity_scores: dict[str, float]
|
||||
is_duplicate: bool
|
||||
is_similar: bool
|
||||
explanation: str
|
||||
|
||||
def to_dict(self) -> dict[str, Any]:
|
||||
return {
|
||||
"issue_a": self.issue_a,
|
||||
"issue_b": self.issue_b,
|
||||
"overall_score": self.overall_score,
|
||||
"title_score": self.title_score,
|
||||
"body_score": self.body_score,
|
||||
"entity_scores": self.entity_scores,
|
||||
"is_duplicate": self.is_duplicate,
|
||||
"is_similar": self.is_similar,
|
||||
"explanation": self.explanation,
|
||||
}
|
||||
|
||||
|
||||
@dataclass
|
||||
class CachedEmbedding:
|
||||
"""Cached embedding with metadata."""
|
||||
|
||||
issue_number: int
|
||||
content_hash: str
|
||||
embedding: list[float]
|
||||
created_at: str
|
||||
expires_at: str
|
||||
|
||||
def is_expired(self) -> bool:
|
||||
expires = datetime.fromisoformat(self.expires_at)
|
||||
return datetime.now(timezone.utc) > expires
|
||||
|
||||
def to_dict(self) -> dict[str, Any]:
|
||||
return {
|
||||
"issue_number": self.issue_number,
|
||||
"content_hash": self.content_hash,
|
||||
"embedding": self.embedding,
|
||||
"created_at": self.created_at,
|
||||
"expires_at": self.expires_at,
|
||||
}
|
||||
|
||||
@classmethod
|
||||
def from_dict(cls, data: dict[str, Any]) -> CachedEmbedding:
|
||||
return cls(**data)
|
||||
|
||||
|
||||
class EntityExtractor:
|
||||
"""Extracts entities from issue content."""
|
||||
|
||||
# Patterns for entity extraction
|
||||
ERROR_CODE_PATTERN = re.compile(
|
||||
r"\b(?:E|ERR|ERROR|WARN|WARNING|FATAL)[-_]?\d{3,5}\b"
|
||||
r"|\b[A-Z]{2,5}[-_]\d{3,5}\b"
|
||||
r"|\bError\s*:\s*[A-Z_]+\b",
|
||||
re.IGNORECASE,
|
||||
)
|
||||
|
||||
FILE_PATH_PATTERN = re.compile(
|
||||
r"(?:^|\s|[\"'`])([a-zA-Z0-9_./\\-]+\.[a-zA-Z]{1,5})(?:\s|[\"'`]|$|:|\()"
|
||||
r"|(?:at\s+)([a-zA-Z0-9_./\\-]+\.[a-zA-Z]{1,5})(?::\d+)?",
|
||||
re.MULTILINE,
|
||||
)
|
||||
|
||||
FUNCTION_NAME_PATTERN = re.compile(
|
||||
r"\b([a-zA-Z_][a-zA-Z0-9_]*)\s*\("
|
||||
r"|\bfunction\s+([a-zA-Z_][a-zA-Z0-9_]*)"
|
||||
r"|\bdef\s+([a-zA-Z_][a-zA-Z0-9_]*)"
|
||||
r"|\basync\s+(?:function\s+)?([a-zA-Z_][a-zA-Z0-9_]*)",
|
||||
)
|
||||
|
||||
URL_PATTERN = re.compile(
|
||||
r"https?://[^\s<>\"')\]]+",
|
||||
re.IGNORECASE,
|
||||
)
|
||||
|
||||
VERSION_PATTERN = re.compile(
|
||||
r"\bv?\d+\.\d+(?:\.\d+)?(?:-[a-zA-Z0-9.]+)?\b",
|
||||
)
|
||||
|
||||
STACK_TRACE_PATTERN = re.compile(
|
||||
r"(?:at\s+[^\n]+\n)+|(?:File\s+\"[^\"]+\",\s+line\s+\d+)",
|
||||
re.MULTILINE,
|
||||
)
|
||||
|
||||
def extract(self, content: str) -> EntityExtraction:
|
||||
"""Extract entities from content."""
|
||||
extraction = EntityExtraction()
|
||||
|
||||
# Extract error codes
|
||||
extraction.error_codes = list(set(self.ERROR_CODE_PATTERN.findall(content)))
|
||||
|
||||
# Extract file paths
|
||||
path_matches = self.FILE_PATH_PATTERN.findall(content)
|
||||
paths = []
|
||||
for match in path_matches:
|
||||
path = match[0] or match[1]
|
||||
if path and len(path) > 3: # Filter out short false positives
|
||||
paths.append(path)
|
||||
extraction.file_paths = list(set(paths))
|
||||
|
||||
# Extract function names
|
||||
func_matches = self.FUNCTION_NAME_PATTERN.findall(content)
|
||||
funcs = []
|
||||
for match in func_matches:
|
||||
func = next((m for m in match if m), None)
|
||||
if func and len(func) > 2:
|
||||
funcs.append(func)
|
||||
extraction.function_names = list(set(funcs))[:20] # Limit
|
||||
|
||||
# Extract URLs
|
||||
extraction.urls = list(set(self.URL_PATTERN.findall(content)))[:10]
|
||||
|
||||
# Extract versions
|
||||
extraction.versions = list(set(self.VERSION_PATTERN.findall(content)))[:10]
|
||||
|
||||
# Extract stack traces (simplified)
|
||||
traces = self.STACK_TRACE_PATTERN.findall(content)
|
||||
extraction.stack_traces = traces[:3] # Keep first 3
|
||||
|
||||
return extraction
|
||||
|
||||
|
||||
class EmbeddingProvider:
|
||||
"""
|
||||
Abstract embedding provider.
|
||||
|
||||
Supports multiple backends:
|
||||
- OpenAI (text-embedding-3-small)
|
||||
- Voyage AI (voyage-large-2)
|
||||
- Local (sentence-transformers)
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
provider: str = "openai",
|
||||
api_key: str | None = None,
|
||||
model: str | None = None,
|
||||
):
|
||||
self.provider = provider
|
||||
self.api_key = api_key
|
||||
self.model = model or self._default_model()
|
||||
|
||||
def _default_model(self) -> str:
|
||||
defaults = {
|
||||
"openai": "text-embedding-3-small",
|
||||
"voyage": "voyage-large-2",
|
||||
"local": "all-MiniLM-L6-v2",
|
||||
}
|
||||
return defaults.get(self.provider, "text-embedding-3-small")
|
||||
|
||||
async def get_embedding(self, text: str) -> list[float]:
|
||||
"""Get embedding for text."""
|
||||
if self.provider == "openai":
|
||||
return await self._openai_embedding(text)
|
||||
elif self.provider == "voyage":
|
||||
return await self._voyage_embedding(text)
|
||||
else:
|
||||
return await self._local_embedding(text)
|
||||
|
||||
async def _openai_embedding(self, text: str) -> list[float]:
|
||||
"""Get embedding from OpenAI."""
|
||||
try:
|
||||
import openai
|
||||
|
||||
client = openai.AsyncOpenAI(api_key=self.api_key)
|
||||
response = await client.embeddings.create(
|
||||
model=self.model,
|
||||
input=text[:8000], # Limit input
|
||||
)
|
||||
return response.data[0].embedding
|
||||
except Exception as e:
|
||||
logger.error(f"OpenAI embedding error: {e}")
|
||||
raise Exception(
|
||||
f"OpenAI embeddings required but failed: {e}. Configure OPENAI_API_KEY or use 'local' provider."
|
||||
)
|
||||
|
||||
async def _voyage_embedding(self, text: str) -> list[float]:
|
||||
"""Get embedding from Voyage AI."""
|
||||
try:
|
||||
import httpx
|
||||
|
||||
async with httpx.AsyncClient() as client:
|
||||
response = await client.post(
|
||||
"https://api.voyageai.com/v1/embeddings",
|
||||
headers={"Authorization": f"Bearer {self.api_key}"},
|
||||
json={
|
||||
"model": self.model,
|
||||
"input": text[:8000],
|
||||
},
|
||||
)
|
||||
data = response.json()
|
||||
return data["data"][0]["embedding"]
|
||||
except Exception as e:
|
||||
logger.error(f"Voyage embedding error: {e}")
|
||||
raise Exception(
|
||||
f"Voyage embeddings required but failed: {e}. Configure VOYAGE_API_KEY or use 'local' provider."
|
||||
)
|
||||
|
||||
async def _local_embedding(self, text: str) -> list[float]:
|
||||
"""Get embedding from local model."""
|
||||
try:
|
||||
from sentence_transformers import SentenceTransformer
|
||||
|
||||
model = SentenceTransformer(self.model)
|
||||
embedding = model.encode(text[:8000])
|
||||
return embedding.tolist()
|
||||
except Exception as e:
|
||||
logger.error(f"Local embedding error: {e}")
|
||||
raise Exception(
|
||||
f"Local embeddings required but failed: {e}. Install sentence-transformers: pip install sentence-transformers"
|
||||
)
|
||||
|
||||
|
||||
class DuplicateDetector:
|
||||
"""
|
||||
Semantic duplicate detection for GitHub issues.
|
||||
|
||||
Usage:
|
||||
detector = DuplicateDetector(
|
||||
cache_dir=Path(".auto-claude/github/embeddings"),
|
||||
embedding_provider="openai",
|
||||
)
|
||||
|
||||
# Check for duplicates
|
||||
duplicates = await detector.find_duplicates(
|
||||
issue_number=123,
|
||||
title="Login fails with OAuth",
|
||||
body="When trying to login...",
|
||||
open_issues=all_issues,
|
||||
)
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
cache_dir: Path,
|
||||
embedding_provider: str = "openai",
|
||||
api_key: str | None = None,
|
||||
duplicate_threshold: float = DUPLICATE_THRESHOLD,
|
||||
similar_threshold: float = SIMILAR_THRESHOLD,
|
||||
cache_ttl_hours: int = EMBEDDING_CACHE_TTL_HOURS,
|
||||
):
|
||||
self.cache_dir = cache_dir
|
||||
self.cache_dir.mkdir(parents=True, exist_ok=True)
|
||||
self.duplicate_threshold = duplicate_threshold
|
||||
self.similar_threshold = similar_threshold
|
||||
self.cache_ttl_hours = cache_ttl_hours
|
||||
|
||||
self.embedding_provider = EmbeddingProvider(
|
||||
provider=embedding_provider,
|
||||
api_key=api_key,
|
||||
)
|
||||
self.entity_extractor = EntityExtractor()
|
||||
|
||||
def _get_cache_file(self, repo: str) -> Path:
|
||||
safe_name = repo.replace("/", "_")
|
||||
return self.cache_dir / f"{safe_name}_embeddings.json"
|
||||
|
||||
def _content_hash(self, title: str, body: str) -> str:
|
||||
"""Generate hash of issue content."""
|
||||
content = f"{title}\n{body}"
|
||||
return hashlib.sha256(content.encode()).hexdigest()[:16]
|
||||
|
||||
def _load_cache(self, repo: str) -> dict[int, CachedEmbedding]:
|
||||
"""Load embedding cache for a repo."""
|
||||
cache_file = self._get_cache_file(repo)
|
||||
if not cache_file.exists():
|
||||
return {}
|
||||
|
||||
with open(cache_file) as f:
|
||||
data = json.load(f)
|
||||
|
||||
cache = {}
|
||||
for item in data.get("embeddings", []):
|
||||
embedding = CachedEmbedding.from_dict(item)
|
||||
if not embedding.is_expired():
|
||||
cache[embedding.issue_number] = embedding
|
||||
|
||||
return cache
|
||||
|
||||
def _save_cache(self, repo: str, cache: dict[int, CachedEmbedding]) -> None:
|
||||
"""Save embedding cache for a repo."""
|
||||
cache_file = self._get_cache_file(repo)
|
||||
data = {
|
||||
"embeddings": [e.to_dict() for e in cache.values()],
|
||||
"last_updated": datetime.now(timezone.utc).isoformat(),
|
||||
}
|
||||
with open(cache_file, "w") as f:
|
||||
json.dump(data, f)
|
||||
|
||||
async def get_embedding(
|
||||
self,
|
||||
repo: str,
|
||||
issue_number: int,
|
||||
title: str,
|
||||
body: str,
|
||||
) -> list[float]:
|
||||
"""Get embedding for an issue, using cache if available."""
|
||||
cache = self._load_cache(repo)
|
||||
content_hash = self._content_hash(title, body)
|
||||
|
||||
# Check cache
|
||||
if issue_number in cache:
|
||||
cached = cache[issue_number]
|
||||
if cached.content_hash == content_hash and not cached.is_expired():
|
||||
return cached.embedding
|
||||
|
||||
# Generate new embedding
|
||||
content = f"{title}\n\n{body}"
|
||||
embedding = await self.embedding_provider.get_embedding(content)
|
||||
|
||||
# Cache it
|
||||
now = datetime.now(timezone.utc)
|
||||
cache[issue_number] = CachedEmbedding(
|
||||
issue_number=issue_number,
|
||||
content_hash=content_hash,
|
||||
embedding=embedding,
|
||||
created_at=now.isoformat(),
|
||||
expires_at=(now + timedelta(hours=self.cache_ttl_hours)).isoformat(),
|
||||
)
|
||||
self._save_cache(repo, cache)
|
||||
|
||||
return embedding
|
||||
|
||||
def cosine_similarity(self, a: list[float], b: list[float]) -> float:
|
||||
"""Calculate cosine similarity between two embeddings."""
|
||||
if len(a) != len(b):
|
||||
return 0.0
|
||||
|
||||
dot_product = sum(x * y for x, y in zip(a, b))
|
||||
magnitude_a = sum(x * x for x in a) ** 0.5
|
||||
magnitude_b = sum(x * x for x in b) ** 0.5
|
||||
|
||||
if magnitude_a == 0 or magnitude_b == 0:
|
||||
return 0.0
|
||||
|
||||
return dot_product / (magnitude_a * magnitude_b)
|
||||
|
||||
async def compare_issues(
|
||||
self,
|
||||
repo: str,
|
||||
issue_a: dict[str, Any],
|
||||
issue_b: dict[str, Any],
|
||||
) -> SimilarityResult:
|
||||
"""Compare two issues for similarity."""
|
||||
# Get embeddings
|
||||
embed_a = await self.get_embedding(
|
||||
repo,
|
||||
issue_a["number"],
|
||||
issue_a.get("title", ""),
|
||||
issue_a.get("body", ""),
|
||||
)
|
||||
embed_b = await self.get_embedding(
|
||||
repo,
|
||||
issue_b["number"],
|
||||
issue_b.get("title", ""),
|
||||
issue_b.get("body", ""),
|
||||
)
|
||||
|
||||
# Calculate embedding similarity
|
||||
overall_score = self.cosine_similarity(embed_a, embed_b)
|
||||
|
||||
# Get title-only embeddings
|
||||
title_embed_a = await self.embedding_provider.get_embedding(
|
||||
issue_a.get("title", "")
|
||||
)
|
||||
title_embed_b = await self.embedding_provider.get_embedding(
|
||||
issue_b.get("title", "")
|
||||
)
|
||||
title_score = self.cosine_similarity(title_embed_a, title_embed_b)
|
||||
|
||||
# Get body-only score (if bodies exist)
|
||||
body_a = issue_a.get("body", "")
|
||||
body_b = issue_b.get("body", "")
|
||||
if body_a and body_b:
|
||||
body_embed_a = await self.embedding_provider.get_embedding(body_a)
|
||||
body_embed_b = await self.embedding_provider.get_embedding(body_b)
|
||||
body_score = self.cosine_similarity(body_embed_a, body_embed_b)
|
||||
else:
|
||||
body_score = 0.0
|
||||
|
||||
# Extract and compare entities
|
||||
entities_a = self.entity_extractor.extract(
|
||||
f"{issue_a.get('title', '')} {issue_a.get('body', '')}"
|
||||
)
|
||||
entities_b = self.entity_extractor.extract(
|
||||
f"{issue_b.get('title', '')} {issue_b.get('body', '')}"
|
||||
)
|
||||
entity_scores = entities_a.overlap_with(entities_b)
|
||||
|
||||
# Determine duplicate/similar status
|
||||
is_duplicate = overall_score >= self.duplicate_threshold
|
||||
is_similar = overall_score >= self.similar_threshold
|
||||
|
||||
# Generate explanation
|
||||
explanation = self._generate_explanation(
|
||||
overall_score,
|
||||
title_score,
|
||||
body_score,
|
||||
entity_scores,
|
||||
is_duplicate,
|
||||
)
|
||||
|
||||
return SimilarityResult(
|
||||
issue_a=issue_a["number"],
|
||||
issue_b=issue_b["number"],
|
||||
overall_score=overall_score,
|
||||
title_score=title_score,
|
||||
body_score=body_score,
|
||||
entity_scores=entity_scores,
|
||||
is_duplicate=is_duplicate,
|
||||
is_similar=is_similar,
|
||||
explanation=explanation,
|
||||
)
|
||||
|
||||
def _generate_explanation(
|
||||
self,
|
||||
overall: float,
|
||||
title: float,
|
||||
body: float,
|
||||
entities: dict[str, float],
|
||||
is_duplicate: bool,
|
||||
) -> str:
|
||||
"""Generate human-readable explanation of similarity."""
|
||||
parts = []
|
||||
|
||||
if is_duplicate:
|
||||
parts.append(f"High semantic similarity ({overall:.0%})")
|
||||
else:
|
||||
parts.append(f"Moderate similarity ({overall:.0%})")
|
||||
|
||||
parts.append(f"Title: {title:.0%}")
|
||||
parts.append(f"Body: {body:.0%}")
|
||||
|
||||
# Highlight matching entities
|
||||
for entity_type, score in entities.items():
|
||||
if score > 0:
|
||||
parts.append(f"{entity_type.replace('_', ' ').title()}: {score:.0%}")
|
||||
|
||||
return " | ".join(parts)
|
||||
|
||||
async def find_duplicates(
|
||||
self,
|
||||
repo: str,
|
||||
issue_number: int,
|
||||
title: str,
|
||||
body: str,
|
||||
open_issues: list[dict[str, Any]],
|
||||
limit: int = 5,
|
||||
) -> list[SimilarityResult]:
|
||||
"""
|
||||
Find potential duplicates for an issue.
|
||||
|
||||
Args:
|
||||
repo: Repository in owner/repo format
|
||||
issue_number: Issue to find duplicates for
|
||||
title: Issue title
|
||||
body: Issue body
|
||||
open_issues: List of open issues to compare against
|
||||
limit: Maximum duplicates to return
|
||||
|
||||
Returns:
|
||||
List of SimilarityResult sorted by similarity
|
||||
"""
|
||||
target_issue = {
|
||||
"number": issue_number,
|
||||
"title": title,
|
||||
"body": body,
|
||||
}
|
||||
|
||||
results = []
|
||||
for issue in open_issues:
|
||||
if issue.get("number") == issue_number:
|
||||
continue
|
||||
|
||||
try:
|
||||
result = await self.compare_issues(repo, target_issue, issue)
|
||||
if result.is_similar:
|
||||
results.append(result)
|
||||
except Exception as e:
|
||||
logger.error(f"Error comparing issues: {e}")
|
||||
|
||||
# Sort by overall score, descending
|
||||
results.sort(key=lambda r: r.overall_score, reverse=True)
|
||||
return results[:limit]
|
||||
|
||||
async def precompute_embeddings(
|
||||
self,
|
||||
repo: str,
|
||||
issues: list[dict[str, Any]],
|
||||
) -> int:
|
||||
"""
|
||||
Precompute embeddings for all issues.
|
||||
|
||||
Args:
|
||||
repo: Repository
|
||||
issues: List of issues
|
||||
|
||||
Returns:
|
||||
Number of embeddings computed
|
||||
"""
|
||||
count = 0
|
||||
for issue in issues:
|
||||
try:
|
||||
await self.get_embedding(
|
||||
repo,
|
||||
issue["number"],
|
||||
issue.get("title", ""),
|
||||
issue.get("body", ""),
|
||||
)
|
||||
count += 1
|
||||
except Exception as e:
|
||||
logger.error(f"Error computing embedding for #{issue['number']}: {e}")
|
||||
|
||||
return count
|
||||
|
||||
def clear_cache(self, repo: str) -> None:
|
||||
"""Clear embedding cache for a repo."""
|
||||
cache_file = self._get_cache_file(repo)
|
||||
if cache_file.exists():
|
||||
cache_file.unlink()
|
||||
@@ -1,499 +0,0 @@
|
||||
"""
|
||||
GitHub Automation Error Types
|
||||
=============================
|
||||
|
||||
Structured error types for GitHub automation with:
|
||||
- Serializable error objects for IPC
|
||||
- Stack trace preservation
|
||||
- Error categorization for UI display
|
||||
- Actionable error messages with retry hints
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import traceback
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import datetime, timezone
|
||||
from enum import Enum
|
||||
from typing import Any
|
||||
|
||||
|
||||
class ErrorCategory(str, Enum):
|
||||
"""Categories of errors for UI display and handling."""
|
||||
|
||||
# Authentication/Permission errors
|
||||
AUTHENTICATION = "authentication"
|
||||
PERMISSION = "permission"
|
||||
TOKEN_EXPIRED = "token_expired"
|
||||
INSUFFICIENT_SCOPE = "insufficient_scope"
|
||||
|
||||
# Rate limiting errors
|
||||
RATE_LIMITED = "rate_limited"
|
||||
COST_EXCEEDED = "cost_exceeded"
|
||||
|
||||
# Network/API errors
|
||||
NETWORK = "network"
|
||||
TIMEOUT = "timeout"
|
||||
API_ERROR = "api_error"
|
||||
SERVICE_UNAVAILABLE = "service_unavailable"
|
||||
|
||||
# Validation errors
|
||||
VALIDATION = "validation"
|
||||
INVALID_INPUT = "invalid_input"
|
||||
NOT_FOUND = "not_found"
|
||||
|
||||
# State errors
|
||||
INVALID_STATE = "invalid_state"
|
||||
CONFLICT = "conflict"
|
||||
ALREADY_EXISTS = "already_exists"
|
||||
|
||||
# Internal errors
|
||||
INTERNAL = "internal"
|
||||
CONFIGURATION = "configuration"
|
||||
|
||||
# Bot/Automation errors
|
||||
BOT_DETECTED = "bot_detected"
|
||||
CANCELLED = "cancelled"
|
||||
|
||||
|
||||
class ErrorSeverity(str, Enum):
|
||||
"""Severity levels for errors."""
|
||||
|
||||
INFO = "info" # Informational, not really an error
|
||||
WARNING = "warning" # Something went wrong but recoverable
|
||||
ERROR = "error" # Operation failed
|
||||
CRITICAL = "critical" # System-level failure
|
||||
|
||||
|
||||
@dataclass
|
||||
class StructuredError:
|
||||
"""
|
||||
Structured error object for IPC and UI display.
|
||||
|
||||
This class provides:
|
||||
- Serialization for sending errors to frontend
|
||||
- Stack trace preservation
|
||||
- Actionable messages and retry hints
|
||||
- Error categorization
|
||||
"""
|
||||
|
||||
# Core error info
|
||||
message: str
|
||||
category: ErrorCategory
|
||||
severity: ErrorSeverity = ErrorSeverity.ERROR
|
||||
|
||||
# Context
|
||||
code: str | None = None # Machine-readable error code
|
||||
correlation_id: str | None = None
|
||||
timestamp: str = field(
|
||||
default_factory=lambda: datetime.now(timezone.utc).isoformat()
|
||||
)
|
||||
|
||||
# Details
|
||||
details: dict[str, Any] = field(default_factory=dict)
|
||||
stack_trace: str | None = None
|
||||
|
||||
# Recovery hints
|
||||
retryable: bool = False
|
||||
retry_after_seconds: int | None = None
|
||||
action_hint: str | None = None # e.g., "Click retry to attempt again"
|
||||
help_url: str | None = None
|
||||
|
||||
# Source info
|
||||
source: str | None = None # e.g., "orchestrator.review_pr"
|
||||
pr_number: int | None = None
|
||||
issue_number: int | None = None
|
||||
repo: str | None = None
|
||||
|
||||
def to_dict(self) -> dict[str, Any]:
|
||||
"""Convert to dictionary for JSON serialization."""
|
||||
return {
|
||||
"message": self.message,
|
||||
"category": self.category.value,
|
||||
"severity": self.severity.value,
|
||||
"code": self.code,
|
||||
"correlation_id": self.correlation_id,
|
||||
"timestamp": self.timestamp,
|
||||
"details": self.details,
|
||||
"stack_trace": self.stack_trace,
|
||||
"retryable": self.retryable,
|
||||
"retry_after_seconds": self.retry_after_seconds,
|
||||
"action_hint": self.action_hint,
|
||||
"help_url": self.help_url,
|
||||
"source": self.source,
|
||||
"pr_number": self.pr_number,
|
||||
"issue_number": self.issue_number,
|
||||
"repo": self.repo,
|
||||
}
|
||||
|
||||
@classmethod
|
||||
def from_exception(
|
||||
cls,
|
||||
exc: Exception,
|
||||
category: ErrorCategory = ErrorCategory.INTERNAL,
|
||||
severity: ErrorSeverity = ErrorSeverity.ERROR,
|
||||
correlation_id: str | None = None,
|
||||
**kwargs,
|
||||
) -> StructuredError:
|
||||
"""Create a StructuredError from an exception."""
|
||||
return cls(
|
||||
message=str(exc),
|
||||
category=category,
|
||||
severity=severity,
|
||||
correlation_id=correlation_id,
|
||||
stack_trace=traceback.format_exc(),
|
||||
code=exc.__class__.__name__,
|
||||
**kwargs,
|
||||
)
|
||||
|
||||
|
||||
# Custom Exception Classes with structured error support
|
||||
|
||||
|
||||
class GitHubAutomationError(Exception):
|
||||
"""Base exception for GitHub automation errors."""
|
||||
|
||||
category: ErrorCategory = ErrorCategory.INTERNAL
|
||||
severity: ErrorSeverity = ErrorSeverity.ERROR
|
||||
retryable: bool = False
|
||||
action_hint: str | None = None
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
message: str,
|
||||
details: dict[str, Any] | None = None,
|
||||
correlation_id: str | None = None,
|
||||
**kwargs,
|
||||
):
|
||||
super().__init__(message)
|
||||
self.message = message
|
||||
self.details = details or {}
|
||||
self.correlation_id = correlation_id
|
||||
self.extra = kwargs
|
||||
|
||||
def to_structured_error(self) -> StructuredError:
|
||||
"""Convert to StructuredError for IPC."""
|
||||
return StructuredError(
|
||||
message=self.message,
|
||||
category=self.category,
|
||||
severity=self.severity,
|
||||
code=self.__class__.__name__,
|
||||
correlation_id=self.correlation_id,
|
||||
details=self.details,
|
||||
stack_trace=traceback.format_exc(),
|
||||
retryable=self.retryable,
|
||||
action_hint=self.action_hint,
|
||||
**self.extra,
|
||||
)
|
||||
|
||||
|
||||
class AuthenticationError(GitHubAutomationError):
|
||||
"""Authentication failed."""
|
||||
|
||||
category = ErrorCategory.AUTHENTICATION
|
||||
action_hint = "Check your GitHub token configuration"
|
||||
|
||||
|
||||
class PermissionDeniedError(GitHubAutomationError):
|
||||
"""Permission denied for the operation."""
|
||||
|
||||
category = ErrorCategory.PERMISSION
|
||||
action_hint = "Ensure you have the required permissions"
|
||||
|
||||
|
||||
class TokenExpiredError(GitHubAutomationError):
|
||||
"""GitHub token has expired."""
|
||||
|
||||
category = ErrorCategory.TOKEN_EXPIRED
|
||||
action_hint = "Regenerate your GitHub token"
|
||||
|
||||
|
||||
class InsufficientScopeError(GitHubAutomationError):
|
||||
"""Token lacks required scopes."""
|
||||
|
||||
category = ErrorCategory.INSUFFICIENT_SCOPE
|
||||
action_hint = "Regenerate token with required scopes: repo, read:org"
|
||||
|
||||
|
||||
class RateLimitError(GitHubAutomationError):
|
||||
"""Rate limit exceeded."""
|
||||
|
||||
category = ErrorCategory.RATE_LIMITED
|
||||
severity = ErrorSeverity.WARNING
|
||||
retryable = True
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
message: str,
|
||||
retry_after_seconds: int = 60,
|
||||
**kwargs,
|
||||
):
|
||||
super().__init__(message, **kwargs)
|
||||
self.retry_after_seconds = retry_after_seconds
|
||||
self.action_hint = f"Rate limited. Retry in {retry_after_seconds} seconds"
|
||||
|
||||
def to_structured_error(self) -> StructuredError:
|
||||
error = super().to_structured_error()
|
||||
error.retry_after_seconds = self.retry_after_seconds
|
||||
return error
|
||||
|
||||
|
||||
class CostLimitError(GitHubAutomationError):
|
||||
"""AI cost limit exceeded."""
|
||||
|
||||
category = ErrorCategory.COST_EXCEEDED
|
||||
action_hint = "Increase cost limit in settings or wait until reset"
|
||||
|
||||
|
||||
class NetworkError(GitHubAutomationError):
|
||||
"""Network connection error."""
|
||||
|
||||
category = ErrorCategory.NETWORK
|
||||
retryable = True
|
||||
action_hint = "Check your internet connection and retry"
|
||||
|
||||
|
||||
class TimeoutError(GitHubAutomationError):
|
||||
"""Operation timed out."""
|
||||
|
||||
category = ErrorCategory.TIMEOUT
|
||||
retryable = True
|
||||
action_hint = "The operation took too long. Try again"
|
||||
|
||||
|
||||
class APIError(GitHubAutomationError):
|
||||
"""GitHub API returned an error."""
|
||||
|
||||
category = ErrorCategory.API_ERROR
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
message: str,
|
||||
status_code: int | None = None,
|
||||
**kwargs,
|
||||
):
|
||||
super().__init__(message, **kwargs)
|
||||
self.status_code = status_code
|
||||
self.details["status_code"] = status_code
|
||||
|
||||
# Set retryable based on status code
|
||||
if status_code and status_code >= 500:
|
||||
self.retryable = True
|
||||
self.action_hint = "GitHub service issue. Retry later"
|
||||
|
||||
|
||||
class ServiceUnavailableError(GitHubAutomationError):
|
||||
"""Service temporarily unavailable."""
|
||||
|
||||
category = ErrorCategory.SERVICE_UNAVAILABLE
|
||||
retryable = True
|
||||
action_hint = "Service temporarily unavailable. Retry in a few minutes"
|
||||
|
||||
|
||||
class ValidationError(GitHubAutomationError):
|
||||
"""Input validation failed."""
|
||||
|
||||
category = ErrorCategory.VALIDATION
|
||||
|
||||
|
||||
class InvalidInputError(GitHubAutomationError):
|
||||
"""Invalid input provided."""
|
||||
|
||||
category = ErrorCategory.INVALID_INPUT
|
||||
|
||||
|
||||
class NotFoundError(GitHubAutomationError):
|
||||
"""Resource not found."""
|
||||
|
||||
category = ErrorCategory.NOT_FOUND
|
||||
|
||||
|
||||
class InvalidStateError(GitHubAutomationError):
|
||||
"""Invalid state transition attempted."""
|
||||
|
||||
category = ErrorCategory.INVALID_STATE
|
||||
|
||||
|
||||
class ConflictError(GitHubAutomationError):
|
||||
"""Conflicting operation detected."""
|
||||
|
||||
category = ErrorCategory.CONFLICT
|
||||
action_hint = "Another operation is in progress. Wait and retry"
|
||||
|
||||
|
||||
class AlreadyExistsError(GitHubAutomationError):
|
||||
"""Resource already exists."""
|
||||
|
||||
category = ErrorCategory.ALREADY_EXISTS
|
||||
|
||||
|
||||
class BotDetectedError(GitHubAutomationError):
|
||||
"""Bot activity detected, skipping to prevent loops."""
|
||||
|
||||
category = ErrorCategory.BOT_DETECTED
|
||||
severity = ErrorSeverity.INFO
|
||||
action_hint = "Skipped to prevent infinite bot loops"
|
||||
|
||||
|
||||
class CancelledError(GitHubAutomationError):
|
||||
"""Operation was cancelled by user."""
|
||||
|
||||
category = ErrorCategory.CANCELLED
|
||||
severity = ErrorSeverity.INFO
|
||||
|
||||
|
||||
class ConfigurationError(GitHubAutomationError):
|
||||
"""Configuration error."""
|
||||
|
||||
category = ErrorCategory.CONFIGURATION
|
||||
action_hint = "Check your configuration settings"
|
||||
|
||||
|
||||
# Error handling utilities
|
||||
|
||||
|
||||
def capture_error(
|
||||
exc: Exception,
|
||||
correlation_id: str | None = None,
|
||||
source: str | None = None,
|
||||
pr_number: int | None = None,
|
||||
issue_number: int | None = None,
|
||||
repo: str | None = None,
|
||||
) -> StructuredError:
|
||||
"""
|
||||
Capture any exception as a StructuredError.
|
||||
|
||||
Handles both GitHubAutomationError subclasses and generic exceptions.
|
||||
"""
|
||||
if isinstance(exc, GitHubAutomationError):
|
||||
error = exc.to_structured_error()
|
||||
error.source = source
|
||||
error.pr_number = pr_number
|
||||
error.issue_number = issue_number
|
||||
error.repo = repo
|
||||
if correlation_id:
|
||||
error.correlation_id = correlation_id
|
||||
return error
|
||||
|
||||
# Map known exception types to categories
|
||||
category = ErrorCategory.INTERNAL
|
||||
retryable = False
|
||||
|
||||
if isinstance(exc, TimeoutError):
|
||||
category = ErrorCategory.TIMEOUT
|
||||
retryable = True
|
||||
elif isinstance(exc, ConnectionError):
|
||||
category = ErrorCategory.NETWORK
|
||||
retryable = True
|
||||
elif isinstance(exc, PermissionError):
|
||||
category = ErrorCategory.PERMISSION
|
||||
elif isinstance(exc, FileNotFoundError):
|
||||
category = ErrorCategory.NOT_FOUND
|
||||
elif isinstance(exc, ValueError):
|
||||
category = ErrorCategory.VALIDATION
|
||||
|
||||
return StructuredError.from_exception(
|
||||
exc,
|
||||
category=category,
|
||||
correlation_id=correlation_id,
|
||||
source=source,
|
||||
pr_number=pr_number,
|
||||
issue_number=issue_number,
|
||||
repo=repo,
|
||||
retryable=retryable,
|
||||
)
|
||||
|
||||
|
||||
def format_error_for_ui(error: StructuredError) -> dict[str, Any]:
|
||||
"""
|
||||
Format error for frontend UI display.
|
||||
|
||||
Returns a simplified structure optimized for UI rendering.
|
||||
"""
|
||||
return {
|
||||
"title": _get_error_title(error.category),
|
||||
"message": error.message,
|
||||
"severity": error.severity.value,
|
||||
"retryable": error.retryable,
|
||||
"retry_after": error.retry_after_seconds,
|
||||
"action": error.action_hint,
|
||||
"details": {
|
||||
"code": error.code,
|
||||
"correlation_id": error.correlation_id,
|
||||
"timestamp": error.timestamp,
|
||||
**error.details,
|
||||
},
|
||||
"expandable": {
|
||||
"stack_trace": error.stack_trace,
|
||||
"help_url": error.help_url,
|
||||
},
|
||||
}
|
||||
|
||||
|
||||
def _get_error_title(category: ErrorCategory) -> str:
|
||||
"""Get human-readable title for error category."""
|
||||
titles = {
|
||||
ErrorCategory.AUTHENTICATION: "Authentication Failed",
|
||||
ErrorCategory.PERMISSION: "Permission Denied",
|
||||
ErrorCategory.TOKEN_EXPIRED: "Token Expired",
|
||||
ErrorCategory.INSUFFICIENT_SCOPE: "Insufficient Permissions",
|
||||
ErrorCategory.RATE_LIMITED: "Rate Limited",
|
||||
ErrorCategory.COST_EXCEEDED: "Cost Limit Exceeded",
|
||||
ErrorCategory.NETWORK: "Network Error",
|
||||
ErrorCategory.TIMEOUT: "Operation Timed Out",
|
||||
ErrorCategory.API_ERROR: "GitHub API Error",
|
||||
ErrorCategory.SERVICE_UNAVAILABLE: "Service Unavailable",
|
||||
ErrorCategory.VALIDATION: "Validation Error",
|
||||
ErrorCategory.INVALID_INPUT: "Invalid Input",
|
||||
ErrorCategory.NOT_FOUND: "Not Found",
|
||||
ErrorCategory.INVALID_STATE: "Invalid State",
|
||||
ErrorCategory.CONFLICT: "Conflict Detected",
|
||||
ErrorCategory.ALREADY_EXISTS: "Already Exists",
|
||||
ErrorCategory.INTERNAL: "Internal Error",
|
||||
ErrorCategory.CONFIGURATION: "Configuration Error",
|
||||
ErrorCategory.BOT_DETECTED: "Bot Activity Detected",
|
||||
ErrorCategory.CANCELLED: "Operation Cancelled",
|
||||
}
|
||||
return titles.get(category, "Error")
|
||||
|
||||
|
||||
# Result type for operations that may fail
|
||||
|
||||
|
||||
@dataclass
|
||||
class Result:
|
||||
"""
|
||||
Result type for operations that may succeed or fail.
|
||||
|
||||
Usage:
|
||||
result = Result.success(data={"findings": [...]})
|
||||
result = Result.failure(error=structured_error)
|
||||
|
||||
if result.ok:
|
||||
process(result.data)
|
||||
else:
|
||||
handle_error(result.error)
|
||||
"""
|
||||
|
||||
ok: bool
|
||||
data: dict[str, Any] | None = None
|
||||
error: StructuredError | None = None
|
||||
|
||||
@classmethod
|
||||
def success(cls, data: dict[str, Any] | None = None) -> Result:
|
||||
return cls(ok=True, data=data)
|
||||
|
||||
@classmethod
|
||||
def failure(cls, error: StructuredError) -> Result:
|
||||
return cls(ok=False, error=error)
|
||||
|
||||
@classmethod
|
||||
def from_exception(cls, exc: Exception, **kwargs) -> Result:
|
||||
return cls.failure(capture_error(exc, **kwargs))
|
||||
|
||||
def to_dict(self) -> dict[str, Any]:
|
||||
return {
|
||||
"ok": self.ok,
|
||||
"data": self.data,
|
||||
"error": self.error.to_dict() if self.error else None,
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user