mirror of
https://github.com/garrytan/gstack.git
synced 2026-11-18 22:24:17 +01:00
Commands that read large git or gh output, including the credential pre-push hook, the pre-merge secret and literal scans and the sealed-output guard, now fail when Bun cuts that output off, instead of judging the part they got. Why: Bun can report exit status 0 together with ENOBUFS and partial stdout, so a push whose diff passed 64 MiB could get a credential past the pre-push hook. Nothing to do: the failure names `SPAWN_OUTPUT_INCOMPLETE` and links its troubleshooting entry. Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>
109 lines
7.0 KiB
TypeScript
Executable File
109 lines
7.0 KiB
TypeScript
Executable File
#!/usr/bin/env -S bun --no-env-file --config=/dev/null
|
|
/**
|
|
* gstack-tasks — a plan review's task list, and its reconciliation across reruns (G2, #1791).
|
|
*
|
|
* gstack-tasks prior --phase <p> [--branch <b>] [--dir <d>] [--json]
|
|
* gstack-tasks add --phase <p> [--branch <b>] [--dir <d>]
|
|
* gstack-tasks supersede --phase <p> --keep <list> [--branch <b>] [--dir <d>] [--json]
|
|
*
|
|
* --dir defaults to <state root>/projects/<gstack-slug SLUG>, --branch to the current git branch.
|
|
* Logic: lib/tasks-prior.ts. Codes: lib/result-codes-plan.ts (TASKS_SUPERSEDE_REFUSED).
|
|
*/
|
|
import { spawnSync } from '../lib/spawn-sync';
|
|
import * as fs from 'node:fs';
|
|
import * as path from 'node:path';
|
|
import { EXIT, exitTableHelp } from '../lib/headless-artifacts';
|
|
import { resultLine } from '../lib/result-codes';
|
|
import { runScriptSync } from '../lib/script-invocation';
|
|
import { resolveStateRoot } from '../lib/state-root';
|
|
import { SupersedeRefused, TASK_PHASES, addRows, finishPending, priorSet, readTaskFiles, rowsFileName, supersede, type TaskPhase } from '../lib/tasks-prior';
|
|
|
|
const HELP = `gstack-tasks — a plan review's task list across reruns
|
|
|
|
prior --phase <p> [--json] the newest earlier list for this phase and branch, and how to reconcile it;
|
|
deletes any rows file an unfinished run left
|
|
add --phase <p> validate the rows file, write this run's list (empty: ran, no findings) and its
|
|
dispositions to task-dispositions-<p>-<branch>.jsonl, then supersede this branch's earlier lists
|
|
supersede --phase <p> --keep <list> [--json] move this branch's reconciled earlier lists out of the aggregate
|
|
|
|
Every command takes [--dir <d>] (default <state root>/projects/<slug>) and [--branch <b>] (default the current git branch).
|
|
Rows file <repo>/.gstack/tmp/tasks-<p>-rows.jsonl, one JSON object per line, written with a file-write tool
|
|
(free text never goes on a command line; a missing file means zero rows):
|
|
task {"id","priority","component","title","source_finding","effort_human","effort_cc"} strings,
|
|
"files" an array of strings, optional "carried_from": "<run_id>/<id>"
|
|
disposition {"prior": "<run_id>/<id>", "disposition": "done" | "dropped", "reason": "<commit or why>"}
|
|
prior prints \`PRIOR_TASKS: none\` or \`PRIOR_TASKS: <file> run=<run_id> tasks=<n>\`, one JSON row per task, then a RECONCILE: line;
|
|
\`PRIOR_TASKS_MALFORMED: <file>:<line>\` goes to stderr for a line that is not a JSON object (skipped, never edited).
|
|
supersede renames each earlier tasks-<p>-*.jsonl whose rows are all this branch and not newer than --keep to
|
|
superseded-<name> and prints \`SUPERSEDED: <file>\` or \`KEPT: <file> (<reason>)\`; --keep must validate first.
|
|
${exitTableHelp()}`;
|
|
|
|
function flag(args: string[], name: string): string | undefined {
|
|
const i = args.indexOf(name);
|
|
return i >= 0 ? args[i + 1] : undefined;
|
|
}
|
|
function usage(message: string): number {
|
|
process.stderr.write(`gstack-tasks: ${message}\n${HELP}\n`);
|
|
return EXIT.usage;
|
|
}
|
|
const git = (...args: string[]) => { const r = spawnSync('git', args, { encoding: 'utf8', timeout: 10_000 }); return r.status === 0 ? r.stdout.trim() : ''; };
|
|
function slug(name: 'SLUG' | 'BRANCH'): string {
|
|
const r = runScriptSync(path.join(import.meta.dir, 'gstack-slug'), ['--get', name], { encoding: 'utf8', timeout: 10_000 });
|
|
return (r.status === 0 && r.stdout.trim()) || 'unknown';
|
|
}
|
|
|
|
/** The repository's git-excluded .gstack/tmp, where a host's file-write tool works without a permission card; the tasks directory outside a repository. */
|
|
function rowsDir(fallback: string): string {
|
|
const top = git('rev-parse', '--show-toplevel');
|
|
if (!top) return fallback;
|
|
const exclude = git('rev-parse', '--git-path', 'info/exclude');
|
|
if (exclude) {
|
|
const file = path.resolve(exclude);
|
|
fs.mkdirSync(path.dirname(file), { recursive: true });
|
|
if (!(fs.existsSync(file) && fs.readFileSync(file, 'utf8').split('\n').includes('/.gstack/tmp/'))) fs.appendFileSync(file, '/.gstack/tmp/\n');
|
|
}
|
|
return path.join(top, '.gstack', 'tmp');
|
|
}
|
|
|
|
function main(argv: string[]): number {
|
|
const [cmd, ...rest] = argv;
|
|
if (!cmd || cmd === '--help' || cmd === '-h' || cmd === 'help') { process.stdout.write(HELP + '\n'); return cmd ? EXIT.ok : EXIT.usage; }
|
|
if (!['prior', 'add', 'supersede'].includes(cmd)) return usage(`unknown command ${cmd}`);
|
|
const phase = flag(rest, '--phase') as TaskPhase | undefined;
|
|
if (!phase || !TASK_PHASES.includes(phase)) return usage(`--phase must be one of ${TASK_PHASES.join(', ')}`);
|
|
const dir = path.resolve(flag(rest, '--dir') ?? path.join(resolveStateRoot(), 'projects', slug('SLUG')));
|
|
const branch = flag(rest, '--branch') ?? (git('rev-parse', '--git-dir') ? git('branch', '--show-current') : 'unknown');
|
|
const json = rest.includes('--json');
|
|
try {
|
|
if (cmd === 'add') {
|
|
const r = addRows(dir, phase, branch, flag(rest, '--branch') ?? slug('BRANCH'), git('rev-parse', 'HEAD') || 'unknown', path.join(rowsDir(dir), rowsFileName(phase)));
|
|
process.stdout.write([`ADDED: tasks=${r.tasks} dispositions=${r.dispositions} ${r.file}`, ...r.superseded.map(f => `SUPERSEDED: ${f}`)].join('\n') + '\n');
|
|
return EXIT.ok;
|
|
}
|
|
if (cmd === 'prior') {
|
|
finishPending(dir, phase);
|
|
fs.rmSync(path.join(rowsDir(dir), rowsFileName(phase)), { force: true });
|
|
const files = readTaskFiles(dir, phase);
|
|
for (const f of files) for (const n of f.malformed) process.stderr.write(`PRIOR_TASKS_MALFORMED: ${f.file}:${n}\n`);
|
|
const prior = priorSet(files, phase, branch);
|
|
if (json) { process.stdout.write(JSON.stringify(prior ?? { file: null, run_id: null, rows: [] }) + '\n'); return EXIT.ok; }
|
|
if (!prior) { process.stdout.write('PRIOR_TASKS: none\n'); return EXIT.ok; }
|
|
process.stdout.write([`PRIOR_TASKS: ${prior.file} run=${prior.run_id} tasks=${prior.rows.length}`, ...prior.rows.map(r => JSON.stringify(r)),
|
|
`RECONCILE: decide each task above in this run's rows file (.gstack/tmp/tasks-${phase}-rows.jsonl). Still needed: list it again with "carried_from": "${prior.run_id}/<id>". Shipped: a disposition row {"prior": "${prior.run_id}/<id>", "disposition": "done", "reason": "<commit>"}. Not wanted: the same with "dropped" and why. gstack-tasks add then retires this list.`].join('\n') + '\n');
|
|
return EXIT.ok;
|
|
}
|
|
const keep = flag(rest, '--keep');
|
|
if (!keep) return usage('supersede needs --keep <the list this run wrote>');
|
|
const r = supersede(dir, phase, branch, keep);
|
|
if (json) process.stdout.write(JSON.stringify(r) + '\n');
|
|
else process.stdout.write([...r.moved.map(f => `SUPERSEDED: ${f}`), ...r.skipped.map(s => `KEPT: ${s.file} (${s.reason})`)].join('\n') + (r.moved.length || r.skipped.length ? '\n' : ''));
|
|
return EXIT.ok;
|
|
} catch (e) {
|
|
if (!(e instanceof SupersedeRefused)) throw e;
|
|
process.stderr.write(resultLine(`gstack-tasks ${cmd}`, 'TASKS_SUPERSEDE_REFUSED', e.message) + '\n');
|
|
return EXIT.refused;
|
|
}
|
|
}
|
|
|
|
process.exitCode = main(process.argv.slice(2));
|