generated from ztimson/template
217 lines
8.1 KiB
JavaScript
217 lines
8.1 KiB
JavaScript
#!/usr/bin/env node
|
|
|
|
import {Ai} from '@ztimson/ai-utils';
|
|
import * as os from 'node:os';
|
|
import * as dotenv from 'dotenv';
|
|
import * as fs from 'node:fs';
|
|
import * as path from 'node:path';
|
|
|
|
dotenv.config({quiet: true, debug: false});
|
|
dotenv.config({path: '.env.local', override: true, quiet: true, debug: false});
|
|
|
|
(async () => {
|
|
let p = process.argv[process.argv.length - 1];
|
|
if(p === 'refine' || p.endsWith('refine.mjs')) p = null;
|
|
if(!/^(\/|[A-Z]:)/m.test(p)) p = path.join(process.cwd(), p);
|
|
|
|
const git = process.env['GIT_HOST'],
|
|
owner = process.env['GIT_OWNER'],
|
|
repo = process.env['GIT_REPO'],
|
|
auth = process.env['GIT_TOKEN'],
|
|
ticket = process.env['TICKET'],
|
|
host = process.env['AI_HOST'],
|
|
model = process.env['AI_MODEL'],
|
|
labelDupe = process.env['LABELS_DUPE'] || 'Review/Duplicate',
|
|
labelEnabled = process.env['LABEL_ENABLED'] || 'Review/AI',
|
|
labelsReq = process.env['LABELS_REQ'] || 'Kind/Aesthetic,Kind/Bug,Kind/DevOps,Kind/Document,Kind/Enhancement,Kind/Refactor,Kind/Security',
|
|
labelsOpt = process.env['LABELS_OPT'] || 'Breaking,Priority,QA',
|
|
token = process.env['AI_TOKEN'];
|
|
|
|
console.log(`Processing issue #${ticket}`);
|
|
|
|
// Fetch issue
|
|
const issueData = await fetch(`${git}/api/v1/repos/${owner}/${repo}/issues/${ticket}`, {
|
|
headers: {'Authorization': `token ${auth}`}
|
|
}).then(async resp => {
|
|
if(resp.ok) return resp.json();
|
|
else throw new Error(`${resp.status} ${await resp.text()}`);
|
|
});
|
|
if(issueData.labels?.length !== 1 || issueData.labels[0]?.name !== labelEnabled) {
|
|
console.log('Skipping');
|
|
return process.exit();
|
|
}
|
|
|
|
// Gather readme & template
|
|
let title = '', type = '', labels = [], readme = '', readmeP = path.join(process.cwd(), 'README.md');
|
|
if(fs.existsSync(readmeP)) readme = fs.readFileSync(readmeP, 'utf-8');
|
|
const template = p ? fs.readFileSync(p, 'utf-8') : `## Description
|
|
|
|
A clear explanation of the request
|
|
|
|
---
|
|
|
|
## Current Behavior
|
|
|
|
what's happening now or the current state/gap
|
|
|
|
## Expected Behavior
|
|
|
|
What should happen instead
|
|
|
|
## Steps to Reproduce / Desired Flow
|
|
|
|
1. First step
|
|
2. Second step
|
|
3. Third step
|
|
|
|
## Additional Context
|
|
|
|
Logs, screenshots, links, related issues
|
|
|
|
## Acceptance Criteria
|
|
|
|
- [ ] Todo requirement
|
|
- [X] Completed requirement
|
|
|
|
## Technical Notes
|
|
|
|
Implementation details, constraints, dependencies, design decisions
|
|
|
|
|
|
| Effort / Weight | Score |
|
|
|-----------------|----------|
|
|
| Size | 0-5 |
|
|
| Complexity | 0-5 |
|
|
| Unknowns | 0-5 |
|
|
| **Total** | **0-15** |
|
|
`;
|
|
|
|
// Create AI
|
|
let options = {ollama: {model, host}};
|
|
if(host === 'anthropic') options = {anthropic: {model, token}};
|
|
else if(host === 'openai') options = {openAi: {model, token}};
|
|
const ai = new Ai({
|
|
...options,
|
|
model: [host, model],
|
|
path: process.env['path'] || os.tmpdir(),
|
|
tools: [{
|
|
name: 'title',
|
|
description: 'Set the ticket title, must be called EXACTLY ONCE',
|
|
args: {title: {type: 'string', description: 'Ticket title, must match format: Module - Verb noun', required: true}},
|
|
fn: (args) => title = args.title
|
|
}, {
|
|
name: 'add_label',
|
|
description: 'Add a label to the ticket',
|
|
args: {label: {type: 'string', description: 'Label name', required: true}},
|
|
fn: async (args) => {
|
|
labels.push(args.label);
|
|
fetch(`${git}/api/v1/repos/${owner}/${repo}/issues/${ticket}/labels`, {
|
|
method: 'POST',
|
|
headers: {'Authorization': `token ${auth}`, 'Content-Type': 'application/json'},
|
|
body: `{"labels":["${args.label}"]}`
|
|
}).then(async resp => { if(!resp.ok) throw new Error(`${resp.status} ${await resp.text()}`); });
|
|
}
|
|
}],
|
|
system: `Transform raw tickets into structured markdown following the template EXACTLY.
|
|
|
|
**MANDATORY STEPS:**
|
|
1. Call \`title\` tool EXACTLY ONCE in format: "[Module] - [Verb] [subject]" (example: Storage - fix file uploads)
|
|
2. Identify one label from each group which best applies to the ticket: ${labelsReq.replace(',', ', ')}
|
|
3. Call the \`add_label\` tool ONCE FOR EVERY LABEL identified in the previous step
|
|
4. Filter the following labels to any that apply to this ticket: ${labelsOpt.replace(',', ', ')}
|
|
5. Call the \`add_label\` tool ONCE FOR EVERY LABEL identified in the previous step
|
|
6. Output the new ticket description in formated markdown matching the following rules:
|
|
|
|
**TEMPLATE RULES:**
|
|
- Use ## headers (match template exactly)
|
|
- Description: Clear summary of the request
|
|
- Current Behavior: What's happening now (remove for Document tickets)
|
|
- Expected Behavior: What should happen (remove for Document tickets)
|
|
- Steps to Reproduce: Numbered list for bugs, flow for enhancements, remove if not applicable
|
|
- Additional Context: Logs, screenshots, links provided by user
|
|
- Acceptance Criteria: Convert to checkboxes (- [ ] format)
|
|
- Technical Notes: Implementation approach, constraints, dependencies
|
|
- Weight table (use exact format below):
|
|
|
|
| Effort / Weight | Score |
|
|
|-----------------|----------|
|
|
| Size | 0-5 |
|
|
| Complexity | 0-5 |
|
|
| Unknowns | 0-5 |
|
|
| **Total** | **0-15** |
|
|
|
|
**SCORING:**
|
|
- Size: # of modules/layers/files affected
|
|
- Complexity: Technical difficulty
|
|
- Unknowns: Research/uncertainty needed
|
|
|
|
**PROJECT README:**
|
|
\`\`\`markdown
|
|
${readme.trim() || 'No README available'}
|
|
\`\`\`
|
|
|
|
**TEMPLATE:**
|
|
\`\`\`markdown
|
|
${template.trim()}
|
|
\`\`\`
|
|
|
|
Output ONLY markdown. No explanations, labels, or extra formatting.`});
|
|
|
|
// Format ticket with AI
|
|
const messages = await ai.language.ask(`Title: ${issueData.title}\n\nDescription:\n${issueData.body || 'No description provided'}`).catch(() => []);
|
|
const body = messages?.pop()?.content;
|
|
if(!body) throw new Error('Invalid response from AI');
|
|
|
|
// Check for duplicates
|
|
const repoInfo = await fetch(`${git}/api/v1/repos/${owner}/${repo}`, {headers: {'Authorization': `token ${auth}`},}).then(resp => resp.ok ? resp.json() : null);
|
|
const search = await fetch(`${git}/api/v1/repos/issues/search`, {
|
|
method: 'POST',
|
|
headers: {'Authorization': `token ${auth}`, 'Content-Type': 'application/json'},
|
|
body: JSON.stringify({
|
|
owner,
|
|
priority_repo_id: repoInfo.id,
|
|
type: 'issues',
|
|
limit: 3,
|
|
q: title
|
|
})
|
|
}).then(resp => resp.ok ? resp.json() : []);
|
|
let dupeId = null;
|
|
const dupeIds = search.map(t => t.id);
|
|
const dupes = search.map(t => `ID: ${t.id}\nTitle: ${t.title}\n\`\`\`markdown\n${t.body}\n\`\`\``).join('\n\n');
|
|
const hasDuplicates = (await ai.language.ask(`ID: ${issueData.id}\nTitle: ${title}\n\`\`\`markdown\n${body}\n\`\`\``, {
|
|
system: `Your job is to identify duplicates. Respond ONLY with the duplicate's ID number or "NONE" if no match exists\n\n${dupes}`
|
|
}))?.pop()?.content;
|
|
// Handle duplicates
|
|
if(hasDuplicates && hasDuplicates !== 'NONE' && (dupeId = dupeIds.find(id => id === hasDuplicates.trim()))) {
|
|
await fetch(`${git}/api/v1/repos/${owner}/${repo}/issues/${ticket}/comments`, {
|
|
method: 'POST',
|
|
headers: {'Authorization': `token ${auth}`, 'Content-Type': 'application/json'},
|
|
body: `{"body": "Duplicate of #${dupeId}"}`
|
|
}).then(async resp => { if(!resp.ok) throw new Error(`${resp.status} ${await resp.text()}`); });
|
|
await fetch(`${git}/api/v1/repos/${owner}/${repo}/issues/${ticket}/labels`, {
|
|
method: 'POST',
|
|
headers: {'Authorization': `token ${auth}`, 'Content-Type': 'application/json'},
|
|
body: `{"labels":["${labelDupe}"]}`
|
|
}).then(async resp => { if(!resp.ok) throw new Error(`${resp.status} ${await resp.text()}`); });
|
|
await fetch(`${git}/api/v1/repos/${owner}/${repo}/issues/${ticket}`, {
|
|
method: 'PATCH',
|
|
headers: {'Authorization': `token ${auth}`, 'Content-Type': 'application/json'},
|
|
body: '{"state": "closed"}'
|
|
}).then(async resp => { if(!resp.ok) throw new Error(`${resp.status} ${await resp.text()}`); });
|
|
console.log('Duplicate');
|
|
return process.exit();
|
|
}
|
|
|
|
// Update ticket
|
|
await fetch(`${git}/api/v1/repos/${owner}/${repo}/issues/${ticket}`, {
|
|
method: 'PATCH',
|
|
headers: {'Authorization': `token ${auth}`, 'Content-Type': 'application/json'},
|
|
body: JSON.stringify({title, body})
|
|
}).then(async resp => { if(!resp.ok) throw new Error(`${resp.status} ${await resp.text()}`); });
|
|
|
|
console.log(`Title: ${title}\nLabels: ${labels.join(', ')}\nBody:\n${body}`);
|
|
})().catch(err => {
|
|
console.error(`Error: ${err.message || err.toString()}`);
|
|
process.exit(1);
|
|
});
|