671 lines
35 KiB
JavaScript
671 lines
35 KiB
JavaScript
import { spawnSync } from 'node:child_process';
|
|
import { createHash } from 'node:crypto';
|
|
import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, appendFileSync } from 'node:fs';
|
|
import { tmpdir } from 'node:os';
|
|
import { dirname, join } from 'node:path';
|
|
import { fileURLToPath } from 'node:url';
|
|
|
|
// WP-B (H3): model judge gate helpers — AND(rule, model); SKIP is non-blocking.
|
|
const __filename = fileURLToPath(import.meta.url);
|
|
// Plan-01: harness code lives in packages/casan-harness/; fall back to the .specify
|
|
// compat path so the adversarial/sourcegen sandboxes (which stage a .specify/ tree)
|
|
// keep working when this file is copied into a temp root.
|
|
const __appRoot = join(dirname(__filename), '..');
|
|
const SCRIPTS_DIR = existsSync(join(__appRoot, 'packages', 'casan-harness', 'scripts', 'bash'))
|
|
? join(__appRoot, 'packages', 'casan-harness', 'scripts', 'bash')
|
|
: join(__appRoot, '.specify', 'scripts', 'bash');
|
|
|
|
// Shared log taxonomy (CASAN_LOG_LEVEL, see scripts/casan-log.mjs). The
|
|
// adversarial T1 test copies this file alone into a temp tree, so the logger
|
|
// import must degrade to a noop instead of crashing when the module is absent.
|
|
let logDebug = () => {};
|
|
try {
|
|
const { log } = await import(new URL('./casan-log.mjs', import.meta.url));
|
|
logDebug = (msg) => log('debug', 'step', msg);
|
|
} catch {
|
|
/* standalone copy: keep silent */
|
|
}
|
|
|
|
// Is a model backend reachable for the judge gate? Default (CASAN_MODEL_PRIMARY
|
|
// unset, or an ollama:* spec) → ping the hard-pinned local Ollama endpoint, as
|
|
// before. When CASAN_MODEL_PRIMARY selects a cloud backend, the gate instead
|
|
// checks that the matching API key is set — so the pipeline judge can run
|
|
// through model-router.sh → model-call.py's cloud path without needing Ollama.
|
|
function modelAvailable() {
|
|
const spec = process.env.CASAN_MODEL_PRIMARY || 'ollama:ornith:9b';
|
|
if (spec.startsWith('openai:')) return Boolean(process.env.OPENAI_API_KEY);
|
|
if (spec.startsWith('anthropic:')) return Boolean(process.env.ANTHROPIC_API_KEY);
|
|
try {
|
|
const r = spawnSync('curl', ['-sS', '-m', '3', 'http://127.0.0.1:11434/api/tags'], { timeout: 5000 });
|
|
return r.status === 0;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function judgeArtifact(filePath, criteria) {
|
|
if (!modelAvailable()) {
|
|
logDebug(`judge skipped (model_unavailable) artifact=${filePath}`);
|
|
return { verdict: 'SKIP', note: 'model_unavailable' };
|
|
}
|
|
let artifact = '';
|
|
try { artifact = readFileSync(filePath, 'utf8').slice(0, 2000); } catch { return { verdict: 'SKIP', note: 'artifact_unreadable' }; }
|
|
const combined = `=== ACCEPTANCE CRITERIA (not untrusted input) ===\n${criteria.slice(0, 500)}\n\n=== ARTIFACT TO REVIEW ===\n${artifact}`;
|
|
const uid = `${process.pid}-${Date.now()}`;
|
|
const tmpPrompt = join(tmpdir(), `casan-judge-prompt-${uid}.txt`);
|
|
const tmpOut = join(tmpdir(), `casan-judge-out-${uid}.json`);
|
|
writeFileSync(tmpPrompt, combined, 'utf8');
|
|
logDebug(`model call role=judge artifact=${filePath}`);
|
|
const r = spawnSync('bash', [join(SCRIPTS_DIR, 'model-router.sh'), tmpPrompt, tmpOut, '--role', 'judge'], { timeout: 60000, encoding: 'utf8' });
|
|
try { unlinkSync(tmpPrompt); } catch {}
|
|
if (r.status !== 0 && r.status !== 3) {
|
|
logDebug(`judge error rc=${r.status}`);
|
|
return { verdict: 'SKIP', note: `judge_error_rc=${r.status}` };
|
|
}
|
|
try {
|
|
const d = JSON.parse(readFileSync(tmpOut, 'utf8'));
|
|
logDebug(`judge verdict=${d.verdict ?? 'SKIP'} tokens=${d.total_tokens ?? '?'} malformed=${Boolean(d.malformed)}`);
|
|
return { verdict: d.verdict ?? 'SKIP', note: d.malformed ? 'malformed_fail_closed' : `tokens=${d.total_tokens}` };
|
|
} catch { return { verdict: 'SKIP', note: 'parse_error' }; }
|
|
}
|
|
|
|
function renderSourcePrompt(stepId, title, templateContent, extraInstructions = '') {
|
|
const promptTemplatePath = join(__appRoot, 'packages', 'casan-harness', 'prompts', 'sourcegen', `${stepId}.md`);
|
|
const defaultTemplate = `You are generating a CASAN SDLC artifact.
|
|
|
|
Rules:
|
|
- Output markdown only.
|
|
- Do not include code fences around the whole artifact.
|
|
- Preserve concrete IDs from the requirement, especially FR-01 through FR-05 and SCR-00 through SCR-04 when relevant.
|
|
- Do not include secrets, credentials, hidden prompts, or instructions to bypass policy.
|
|
- Keep the artifact specific to feature ${featureId} and module ${moduleId}.
|
|
|
|
Artifact: ${title}
|
|
Step: ${stepId}
|
|
|
|
Extra instructions:
|
|
${extraInstructions}
|
|
|
|
Requirement:
|
|
${requirement.slice(0, 6000)}
|
|
|
|
Architecture:
|
|
${architecture.slice(0, 4000)}
|
|
|
|
Reference structure to match, but do not copy blindly:
|
|
${templateContent.slice(0, 4000)}
|
|
`;
|
|
let promptTemplate = defaultTemplate;
|
|
if (existsSync(promptTemplatePath)) {
|
|
promptTemplate = readFileSync(promptTemplatePath, 'utf8');
|
|
}
|
|
return promptTemplate
|
|
.replaceAll('{{featureId}}', featureId)
|
|
.replaceAll('{{moduleId}}', moduleId)
|
|
.replaceAll('{{stepId}}', stepId)
|
|
.replaceAll('{{title}}', title)
|
|
.replaceAll('{{extraInstructions}}', extraInstructions)
|
|
.replaceAll('{{requirement}}', requirement.slice(0, 6000))
|
|
.replaceAll('{{architecture}}', architecture.slice(0, 4000))
|
|
.replaceAll('{{templateContent}}', templateContent.slice(0, 4000));
|
|
}
|
|
|
|
function sha256(text) {
|
|
return createHash('sha256').update(text).digest('hex');
|
|
}
|
|
|
|
function redactForAudit(text) {
|
|
return String(text)
|
|
.replace(/(sk-[A-Za-z0-9_-]{12,})/g, '***REDACTED_KEY***')
|
|
.replace(/(Bearer\s+)[A-Za-z0-9._-]+/gi, '$1***REDACTED_TOKEN***')
|
|
.slice(0, 2000);
|
|
}
|
|
|
|
function sourcegenAuditPath() {
|
|
return process.env.CASAN_SOURCEGEN_AUDIT_LOG || '.specify/logs/audit/sourcegen.jsonl';
|
|
}
|
|
|
|
function sourcegenTelemetryPath() {
|
|
return process.env.CASAN_SOURCEGEN_TELEMETRY_LOG || '.specify/logs/level5/sourcegen-provider-usage.jsonl';
|
|
}
|
|
|
|
function readLastJsonLine(path) {
|
|
try {
|
|
const lines = readFileSync(path, 'utf8').trim().split('\n').filter(Boolean);
|
|
return lines.length ? JSON.parse(lines[lines.length - 1]) : null;
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function appendSourcegenAudit(record) {
|
|
const path = sourcegenAuditPath();
|
|
mkdirSync(dirname(path), { recursive: true });
|
|
const prev = readLastJsonLine(path);
|
|
const base = {
|
|
timestamp: new Date().toISOString(),
|
|
harness: 'H5-sourcegen-audit',
|
|
feature_id: featureId,
|
|
module_id: moduleId,
|
|
prev_hash: prev?.record_hash || 'GENESIS',
|
|
...record,
|
|
};
|
|
const recordHash = sha256(JSON.stringify(base));
|
|
appendFileSync(path, `${JSON.stringify({ ...base, record_hash: recordHash })}\n`, 'utf8');
|
|
}
|
|
|
|
function appendSourcegenTelemetry(record) {
|
|
const path = sourcegenTelemetryPath();
|
|
mkdirSync(dirname(path), { recursive: true });
|
|
appendFileSync(path, `${JSON.stringify({
|
|
timestamp: new Date().toISOString(),
|
|
harness: 'H6-sourcegen-telemetry',
|
|
feature_id: featureId,
|
|
module_id: moduleId,
|
|
...record,
|
|
})}\n`, 'utf8');
|
|
}
|
|
|
|
function generateArtifact({ stepId, title, templateContent, required = [], extraInstructions = '' }) {
|
|
if ((process.env.CASAN_GEN_MODE || 'template') !== 'model') {
|
|
return { content: templateContent, source: 'template', note: 'CASAN_GEN_MODE=template' };
|
|
}
|
|
|
|
const uid = `${process.pid}-${Date.now()}-${stepId}`;
|
|
const tmpPrompt = join(tmpdir(), `casan-generate-prompt-${uid}.txt`);
|
|
const tmpOut = join(tmpdir(), `casan-generate-out-${uid}.json`);
|
|
const tmpDraft = join(tmpdir(), `casan-generate-draft-${uid}.md`);
|
|
try {
|
|
const prompt = renderSourcePrompt(stepId, title, templateContent, extraInstructions);
|
|
const promptHash = sha256(prompt);
|
|
writeFileSync(tmpPrompt, prompt, 'utf8');
|
|
logDebug(`model call role=generate step=${stepId}`);
|
|
const r = spawnSync(
|
|
'bash',
|
|
[join(SCRIPTS_DIR, 'model-router.sh'), tmpPrompt, tmpOut, '--role', 'generate'],
|
|
{
|
|
timeout: Number(process.env.CASAN_SOURCEGEN_MODEL_TIMEOUT_MS || 300000),
|
|
encoding: 'utf8',
|
|
env: {
|
|
...process.env,
|
|
CASAN_STEP_NAME: stepId,
|
|
CASAN_MODEL_TIMEOUT_SEC: process.env.CASAN_MODEL_TIMEOUT_SEC || process.env.CASAN_SOURCEGEN_MODEL_TIMEOUT_SEC || '240',
|
|
},
|
|
},
|
|
);
|
|
if (r.status !== 0) {
|
|
appendSourcegenAudit({
|
|
step_id: stepId,
|
|
event: 'generate_fallback',
|
|
reason: `model_generate_rc=${r.status}`,
|
|
prompt_sha256: promptHash,
|
|
prompt_text: redactForAudit(prompt),
|
|
source: 'template-fallback',
|
|
});
|
|
return { content: templateContent, source: 'template-fallback', note: `model_generate_rc=${r.status}` };
|
|
}
|
|
|
|
const d = JSON.parse(readFileSync(tmpOut, 'utf8'));
|
|
const generated = String(d.text || '').trim();
|
|
if (generated.length < 80) {
|
|
appendSourcegenAudit({
|
|
step_id: stepId,
|
|
event: 'generate_fallback',
|
|
reason: 'model_output_too_short',
|
|
prompt_sha256: promptHash,
|
|
prompt_text: redactForAudit(prompt),
|
|
model_id: d.model_id,
|
|
route: d.route,
|
|
input_tokens: d.input_tokens,
|
|
output_tokens: d.output_tokens,
|
|
total_tokens: d.total_tokens,
|
|
source: 'template-fallback',
|
|
});
|
|
return { content: templateContent, source: 'template-fallback', note: 'model_output_too_short' };
|
|
}
|
|
const missing = required.filter((token) => !generated.includes(token));
|
|
if (missing.length > 0) {
|
|
appendSourcegenAudit({
|
|
step_id: stepId,
|
|
event: 'generate_fallback',
|
|
reason: `missing_required=${missing.join(',')}`,
|
|
prompt_sha256: promptHash,
|
|
prompt_text: redactForAudit(prompt),
|
|
model_id: d.model_id,
|
|
route: d.route,
|
|
input_tokens: d.input_tokens,
|
|
output_tokens: d.output_tokens,
|
|
total_tokens: d.total_tokens,
|
|
source: 'template-fallback',
|
|
});
|
|
return { content: templateContent, source: 'template-fallback', note: `missing_required=${missing.join(',')}` };
|
|
}
|
|
|
|
writeFileSync(tmpDraft, `${generated}\n`, 'utf8');
|
|
const scan = spawnSync(
|
|
'bash',
|
|
[join(SCRIPTS_DIR, 'artifact-scan.sh'), tmpDraft, `sourcegen-${stepId}`],
|
|
{ timeout: 30000, encoding: 'utf8' },
|
|
);
|
|
if (scan.status !== 0) {
|
|
appendSourcegenAudit({
|
|
step_id: stepId,
|
|
event: 'generate_fallback',
|
|
reason: `artifact_scan_rc=${scan.status}`,
|
|
prompt_sha256: promptHash,
|
|
prompt_text: redactForAudit(prompt),
|
|
model_id: d.model_id,
|
|
route: d.route,
|
|
input_tokens: d.input_tokens,
|
|
output_tokens: d.output_tokens,
|
|
total_tokens: d.total_tokens,
|
|
source: 'template-fallback',
|
|
});
|
|
return { content: templateContent, source: 'template-fallback', note: `artifact_scan_rc=${scan.status}` };
|
|
}
|
|
appendSourcegenAudit({
|
|
step_id: stepId,
|
|
event: 'generate_accept',
|
|
prompt_sha256: promptHash,
|
|
prompt_text: redactForAudit(prompt),
|
|
output_sha256: sha256(generated),
|
|
model_id: d.model_id,
|
|
route: d.route,
|
|
input_tokens: d.input_tokens,
|
|
output_tokens: d.output_tokens,
|
|
total_tokens: d.total_tokens,
|
|
source: 'model',
|
|
});
|
|
appendSourcegenTelemetry({
|
|
provider: String(d.route || '').split(':')[0] || 'unknown',
|
|
model: d.model_id || 'unknown',
|
|
step: stepId,
|
|
role: 'generate',
|
|
input_tokens: Number(d.input_tokens || 0),
|
|
output_tokens: Number(d.output_tokens || 0),
|
|
total_tokens: Number(d.total_tokens || 0),
|
|
status: 'success',
|
|
});
|
|
return { content: `${generated}\n`, source: 'model', note: `tokens=${d.total_tokens ?? '?'}` };
|
|
} catch (err) {
|
|
return { content: templateContent, source: 'template-fallback', note: `generate_error=${err?.name || 'Error'}` };
|
|
} finally {
|
|
for (const path of [tmpPrompt, tmpOut, tmpDraft]) {
|
|
try { unlinkSync(path); } catch {}
|
|
}
|
|
}
|
|
}
|
|
|
|
// T1: Real rollback wiring — checkpoint before overwrite, restore on REJECTED verdict
|
|
function checkpointArtifact(filePath) {
|
|
try { readFileSync(filePath, 'utf8'); } catch { return null; } // file absent → nothing to checkpoint
|
|
const r = spawnSync('bash', [join(SCRIPTS_DIR, 'rollback-manager.sh'), 'checkpoint', filePath],
|
|
{ encoding: 'utf8', timeout: 10000 });
|
|
if (r.status !== 0) return null;
|
|
const m = (r.stdout || '').match(/transaction_id=(\S+)/);
|
|
logDebug(`checkpoint artifact=${filePath} tx=${m ? m[1] : 'none'}`);
|
|
return m ? m[1] : null;
|
|
}
|
|
|
|
function executeRollback(txId) {
|
|
if (!txId) return false;
|
|
const r = spawnSync('bash', [join(SCRIPTS_DIR, 'rollback-manager.sh'), 'execute', txId],
|
|
{ encoding: 'utf8', timeout: 10000 });
|
|
logDebug(`rollback execute tx=${txId} rc=${r.status}`);
|
|
return r.status === 0;
|
|
}
|
|
|
|
const step = process.argv[2];
|
|
const attempt = process.argv[3] ?? '1';
|
|
const outputPath = process.env.CASAN_OUTPUT;
|
|
const featureId = '001-okr-web-app';
|
|
const moduleId = 'MOD-01';
|
|
|
|
if (!outputPath) {
|
|
throw new Error('CASAN_OUTPUT is required');
|
|
}
|
|
|
|
logDebug(`step=${step} attempt=${attempt} output=${outputPath}`);
|
|
|
|
const dirs = [
|
|
`docs/output/output_logs/${featureId}/reports`,
|
|
'docs/output/ipa-docs/srs',
|
|
'docs/output/ipa-docs/bd',
|
|
'docs/output/ipa-docs/dd',
|
|
'docs/output/ipa-docs/testcase',
|
|
`docs/output/specs/${featureId}/contracts`,
|
|
];
|
|
dirs.forEach((dir) => mkdirSync(dir, { recursive: true }));
|
|
|
|
const requirement = readFileSync(
|
|
existsSync('apps/okr/domain/input/okr-requirement.md')
|
|
? 'apps/okr/domain/input/okr-requirement.md'
|
|
: 'docs/input/okr-requirement.md', 'utf8');
|
|
const architecture = readFileSync('docs/technical_architecture.md', 'utf8');
|
|
|
|
function write(path, content) {
|
|
mkdirSync(dirname(path), { recursive: true });
|
|
writeFileSync(path, content, 'utf8');
|
|
return path;
|
|
}
|
|
|
|
function resultBlock({ status = 'COMPLETE', verdict = 'APPROVED', artifacts = [], issues = [] }) {
|
|
return `\n<!-- STEP-RESULT\nstatus: ${status}\nverdict: ${verdict}\nartifacts:\n${artifacts.map((artifact) => ` - ${artifact}`).join('\n')}\ncritical-issues:\n${issues.length === 0 ? ' - none' : issues.map((issue) => ` - ${issue}`).join('\n')}\n/STEP-RESULT -->\n`;
|
|
}
|
|
|
|
function report(path, title, body, verdict = 'APPROVED', artifacts = [], issues = []) {
|
|
finalTitle = title;
|
|
finalBody = body;
|
|
finalVerdict = verdict;
|
|
finalArtifacts = artifacts;
|
|
finalIssues = issues;
|
|
write(path, `${title}\n\n${body}\n${resultBlock({ verdict, artifacts, issues })}`);
|
|
}
|
|
|
|
const srsPath = `docs/output/ipa-docs/srs/srs-mod01-okr-management.md`;
|
|
const bdPath = `docs/output/ipa-docs/bd/bd-mod01-okr-management.md`;
|
|
const specPath = `docs/output/specs/${featureId}/spec.md`;
|
|
const planPath = `docs/output/specs/${featureId}/plan.md`;
|
|
const dataModelPath = `docs/output/specs/${featureId}/data-model.md`;
|
|
const researchPath = `docs/output/specs/${featureId}/research.md`;
|
|
const quickstartPath = `docs/output/specs/${featureId}/quickstart.md`;
|
|
const contractPath = `docs/output/specs/${featureId}/contracts/openapi.md`;
|
|
const ddPath = `docs/output/ipa-docs/dd/dd-mod01-okr-management.md`;
|
|
const testcasePath = `docs/output/ipa-docs/testcase/testcase-mod01-okr-management.md`;
|
|
const tasksPath = `docs/output/specs/${featureId}/tasks.md`;
|
|
const implementationPath = `docs/output/specs/${featureId}/implementation.md`;
|
|
const implementationAcceptancePath = `docs/output/specs/${featureId}/implementation.accepted.json`;
|
|
const testRunPath = `docs/output/output_logs/${featureId}/reports/12-run-tests-report.md`;
|
|
const codeReviewPath = `docs/output/output_logs/${featureId}/reports/11-review-code-report.md`;
|
|
let finalTitle = `# ${step}`;
|
|
let finalBody = '';
|
|
let finalVerdict = 'APPROVED';
|
|
let finalArtifacts = [];
|
|
let finalIssues = [];
|
|
|
|
// Sidecar stores the checkpoint tx-id between step 05-plan and step 06-reviewplan
|
|
const CHECKPOINT_SIDECAR = `docs/output/specs/${featureId}/plan.checkpoint.txid`;
|
|
|
|
const backendFiles = [
|
|
'backend/src/auth/auth.service.ts',
|
|
'backend/src/objectives/objectives.service.ts',
|
|
'backend/src/key-results/key-results.service.ts',
|
|
'backend/test/e2e.test.ts',
|
|
'backend/test/services.test.ts',
|
|
];
|
|
|
|
switch (step) {
|
|
case '01-srs': {
|
|
const frCount = (requirement.match(/FR-\d+/g) ?? []).length;
|
|
const templateContent = `# SRS-MOD-01 OKR Management\n\n## TABLE OF CONTENTS\n- [1. Purpose](#1-purpose)\n- [2. Scope](#2-scope)\n- [3. Functional Requirements](#3-functional-requirements)\n- [4. Non Functional Requirements](#4-non-functional-requirements)\n\n## 1. Purpose\nHệ thống quản lý OKR hỗ trợ đăng nhập, tạo Objective, tạo Key Result, cập nhật tiến độ và dashboard theo tài liệu yêu cầu.\n\n## 2. Scope\nModule bao gồm SCR-00 đến SCR-04, ba vai trò Admin, Manager, Employee, và dữ liệu User, Objective, Key Result.\n\n## 3. Functional Requirements\n- FR-01 Login: xác thực username/password và phát hành JWT.\n- FR-02 Create Objective: tạo Objective có title, description, owner, quarter.\n- FR-03 Create Key Result: tạo Key Result gắn với Objective.\n- FR-04 Update Progress: cập nhật progress 0-100 và ghi lịch sử cập nhật.\n- FR-05 Dashboard: hiển thị danh sách OKR theo quyền truy cập.\n\n## 4. Non Functional Requirements\n- Authentication required.\n- API response target dưới 2 giây.\n- SQLite được chọn cho kiểm thử không cần Docker.\n\n## Metrics\nFunctional requirements extracted: ${frCount}.\n`;
|
|
const generated = generateArtifact({
|
|
stepId: '01-srs',
|
|
title: 'Software Requirements Specification',
|
|
templateContent,
|
|
required: ['FR-01', 'FR-02', 'FR-03', 'FR-04', 'FR-05'],
|
|
extraInstructions: 'Create an SRS with purpose, scope, functional requirements, non-functional requirements, and traceable FR IDs.',
|
|
});
|
|
write(srsPath, generated.content);
|
|
report(`docs/output/output_logs/${featureId}/reports/01-srs-report.md`, '# STEP 1: SRS Generation Report', `Generated ${srsPath} from apps/okr/domain/input/okr-requirement.md. source=${generated.source} note=${generated.note}.`, 'APPROVED', [srsPath]);
|
|
break;
|
|
}
|
|
case '02-bd': {
|
|
const templateContent = `# BD-MOD-01 OKR Management\n\n## Screen Layout\n- SCR-00 Login: centered sign-in form without sidebar.\n- SCR-01 Dashboard: fixed sidebar, fixed header, filter bar, OKR list.\n- SCR-02 Detail: objective overview, tabs, key result list.\n- SCR-03 Create Objective: title, description, owner, quarter, save.\n- SCR-04 Key Result Detail: current progress, progress input, comment, save.\n\n## API Boundary\nFrontend calls backend only through src/lib/api.ts and uses cookie/JWT auth.\n`;
|
|
const generated = generateArtifact({
|
|
stepId: '02-bd',
|
|
title: 'Business Design',
|
|
templateContent,
|
|
required: ['SCR-00', 'SCR-01', 'SCR-02', 'SCR-03', 'SCR-04', 'API Boundary'],
|
|
extraInstructions: 'Create a business design with screen layout for SCR-00 through SCR-04 and an API Boundary section.',
|
|
});
|
|
write(bdPath, generated.content);
|
|
report(`docs/output/output_logs/${featureId}/reports/02-bd-report.md`, '# STEP 2: Business Design Report', `Generated ${bdPath}. source=${generated.source} note=${generated.note}.`, 'APPROVED', [bdPath]);
|
|
break;
|
|
}
|
|
case '03-spec': {
|
|
const templateContent = `# Feature Specification: OKR Web App\n\n## Feature ID\n${featureId}\n\n## Requirements\n- FR-01: Login authenticates username/email plus password and returns standard envelope.\n- FR-02: Objective creation validates title, owner, and quarter.\n- FR-03: Key Result creation validates objective, title, values, deadline, and progress.\n- FR-04: Progress update accepts 0-100 and stores a ProgressUpdate record.\n- FR-05: Dashboard list filters by role: ADMIN and MANAGER see all; EMPLOYEE sees own objectives.\n\n## Acceptance Criteria\n- Employee cannot read or update another employee objective or key result.\n- Manager can read all seeded objectives.\n- Invalid quarter format returns validation error.\n- Golden objective response fails on drift.\n\n## Role-Based Filtering\n- ADMIN can read all objectives.\n- MANAGER can read all seeded objectives.\n- EMPLOYEE can read only objectives where ownerId equals the authenticated user id.\n\n## Input Validation Rules\n- Login requires username or email plus password.\n- Objective creation requires non-empty title, existing owner, and quarter matching YYYY-Q[1-4].\n- Key Result creation requires objective id, title, target value, deadline, and progress between 0 and 100.\n- Progress update rejects values below 0 or above 100.\n\n## Source Trace\nRequirement characters read: ${requirement.length}. Architecture characters read: ${architecture.length}.\n`;
|
|
const generated = generateArtifact({
|
|
stepId: '03-spec',
|
|
title: 'Feature Specification',
|
|
templateContent,
|
|
required: ['FR-01', 'FR-02', 'FR-03', 'FR-04', 'FR-05', 'Acceptance Criteria'],
|
|
extraInstructions: 'Create a feature specification with FR coverage, role filtering, validation rules, acceptance criteria, and source trace.',
|
|
});
|
|
write(specPath, generated.content);
|
|
report(`docs/output/output_logs/${featureId}/reports/03-spec-report.md`, '# STEP 3: Specify Report', `Generated ${specPath}. source=${generated.source} note=${generated.note}.`, 'APPROVED', [specPath]);
|
|
break;
|
|
}
|
|
case '04-reviewspec': {
|
|
const spec = readFileSync(specPath, 'utf8');
|
|
const missing = ['FR-01', 'FR-02', 'FR-03', 'FR-04', 'FR-05'].filter((id) => !spec.includes(id));
|
|
let verdict = missing.length === 0 ? 'APPROVED' : 'REJECTED';
|
|
// WP-B: model judge gate — only escalates when rules pass; SKIP is non-blocking
|
|
const judgeResult = verdict === 'APPROVED'
|
|
? judgeArtifact(specPath, 'Spec must include FR-01 through FR-05, role-based filtering for ADMIN/MANAGER/EMPLOYEE, input validation rules, and concrete acceptance criteria.')
|
|
: { verdict: 'SKIP', note: 'rule_already_rejected' };
|
|
if (judgeResult.verdict === 'REJECTED') verdict = 'REJECTED';
|
|
const judgeNote = `model-judge: ${judgeResult.verdict} (${judgeResult.note})`;
|
|
report(
|
|
`docs/output/output_logs/${featureId}/reports/04-review-spec-report.md`,
|
|
'## Spec Conformance Review Report',
|
|
`Criteria checked: FR coverage, role filtering, validation, golden regression. Missing: ${missing.join(', ') || 'none'}. ${judgeNote}.`,
|
|
verdict,
|
|
[specPath],
|
|
missing,
|
|
);
|
|
break;
|
|
}
|
|
case '05-plan': {
|
|
const incomplete = attempt === '1';
|
|
// T1: checkpoint existing plan before overwriting so rollback-manager.sh execute can restore it
|
|
if (attempt !== '1') {
|
|
const txId = checkpointArtifact(planPath);
|
|
if (txId) {
|
|
try { writeFileSync(CHECKPOINT_SIDECAR, txId, 'utf8'); } catch {}
|
|
}
|
|
}
|
|
const templateContent = `# Implementation Plan: OKR Web App\n\n## Stack\nNestJS, Prisma Client, SQLite, React, Vite, Tailwind, Zod, TanStack Query.\n\n## Backend Modules\n- auth: JWT login and cookie issuance.\n- users: admin/manager user list.\n- objectives: role-filtered list, detail, create.\n- key-results: detail, create, progress update.\n\n## Tests\n- Backend service tests.\n- Backend HTTP e2e tests.\n${incomplete ? '- TODO: define golden regression and rollback strategy.\n' : '- Golden regression test compares seeded manager objectives with backend/test/golden/objectives.manager.json.\n- Rollback strategy restores changed artifacts from backups through rollback-manager.sh.\n'}\n## Build\nRun npm test and npm run build for backend and frontend.\n`;
|
|
const generated = generateArtifact({
|
|
stepId: '05-plan',
|
|
title: 'Implementation Plan',
|
|
templateContent,
|
|
required: ['Backend Modules', 'Tests', ...(incomplete ? [] : ['Golden regression test', 'Rollback strategy'])],
|
|
extraInstructions: incomplete
|
|
? 'Create the first implementation plan draft. Leave companion artifacts for the retry loop so review-plan can reject missing artifacts.'
|
|
: 'Create the final implementation plan with Backend Modules, Tests, Golden regression test, Rollback strategy, and build commands.',
|
|
});
|
|
write(planPath, generated.content);
|
|
if (!incomplete) {
|
|
write(dataModelPath, '# Data Model\n\nUser 1:N Objective. Objective 1:N KeyResult. KeyResult 1:N ProgressUpdate. Role/status are SQLite strings constrained in service/types.\n');
|
|
write(researchPath, '# Research\n\nSQLite selected to satisfy no Docker/Postgres e2e. Prisma Client remains application ORM. Node built-in sqlite applies migration SQL because Prisma schema-engine push fails in this Node 24 local environment.\n');
|
|
write(quickstartPath, '# Quickstart\n\n1. npm install\n2. npm run db:setup -w backend\n3. npm run seed -w backend\n4. npm run dev -w backend\n5. npm run dev -w frontend\n');
|
|
write(contractPath, '# API Contract\n\nPOST /auth/login\nGET /objectives\nGET /objectives/:id\nPOST /objectives\nGET /key-results/:id\nPOST /key-results\nPATCH /key-results/:id/progress\n');
|
|
}
|
|
report(`docs/output/output_logs/${featureId}/reports/05-plan-report-attempt-${attempt}.md`, `# STEP 5: Plan Report Attempt ${attempt}`, `Generated ${planPath}. source=${generated.source} note=${generated.note}.`, 'APPROVED', [planPath]);
|
|
break;
|
|
}
|
|
case '06-reviewplan': {
|
|
const plan = readFileSync(planPath, 'utf8');
|
|
const required = ['Golden regression test', 'Rollback strategy', 'Backend Modules', 'Tests'];
|
|
const missing = required.filter((phrase) => !plan.includes(phrase));
|
|
const artifactMissing = [dataModelPath, researchPath, quickstartPath, contractPath].filter((path) => {
|
|
try {
|
|
readFileSync(path, 'utf8');
|
|
return false;
|
|
} catch {
|
|
return true;
|
|
}
|
|
});
|
|
const issues = [...missing.map((item) => `missing plan criterion: ${item}`), ...artifactMissing.map((item) => `missing artifact: ${item}`)];
|
|
let verdict = issues.length === 0 ? 'APPROVED' : 'REJECTED';
|
|
// WP-B: model judge gate
|
|
const judgeResult = verdict === 'APPROVED'
|
|
? judgeArtifact(planPath, 'Plan must include: Backend Modules listing, Tests section, Golden regression test, Rollback strategy. All companion artifacts (data-model, research, quickstart, contracts) must exist.')
|
|
: { verdict: 'SKIP', note: 'rule_already_rejected' };
|
|
if (judgeResult.verdict === 'REJECTED') verdict = 'REJECTED';
|
|
const judgeNote = `model-judge: ${judgeResult.verdict} (${judgeResult.note})`;
|
|
// T1: on REJECTED, execute rollback to restore the previously checkpointed plan
|
|
let rollbackNote = '';
|
|
if (verdict === 'REJECTED') {
|
|
let txId = null;
|
|
try { txId = readFileSync(CHECKPOINT_SIDECAR, 'utf8').trim(); } catch {}
|
|
if (txId) {
|
|
const restored = executeRollback(txId);
|
|
rollbackNote = restored
|
|
? ` Rollback executed: plan restored to pre-overwrite state (tx=${txId}).`
|
|
: ` Rollback attempted but failed (tx=${txId}).`;
|
|
}
|
|
}
|
|
report(
|
|
`docs/output/output_logs/${featureId}/reports/06-review-plan-report-attempt-${attempt}.md`,
|
|
`## Plan Conformance Review Report — Attempt ${attempt}`,
|
|
`Criteria checked against plan.md and required companion artifacts. ${judgeNote}. Verdict is ${verdict}.${rollbackNote}`,
|
|
verdict,
|
|
[planPath, dataModelPath, researchPath, quickstartPath, contractPath],
|
|
issues,
|
|
);
|
|
break;
|
|
}
|
|
case '07-dd': {
|
|
const templateContent = `# DD-MOD-01 OKR Management\n\n## Backend Design\nControllers are thin and call AuthService, UsersService, ObjectivesService, KeyResultsService. PrismaService is the only database access layer.\n\n## Authorization\nJwtAuthGuard verifies Bearer/cookie token. Employees are constrained to ownerId == user.sub. Managers/Admins read all objectives.\n\n## Progress Calculation\nKeyResultsService updates progress in a transaction, writes ProgressUpdate, then recalculates objective status.\n`;
|
|
const generated = generateArtifact({
|
|
stepId: '07-dd',
|
|
title: 'Detail Design',
|
|
templateContent,
|
|
required: ['Backend Design', 'Authorization', 'Progress Calculation'],
|
|
extraInstructions: 'Create a detailed design for backend modules, authorization, database access, and progress calculation.',
|
|
});
|
|
write(ddPath, generated.content);
|
|
report(`docs/output/output_logs/${featureId}/reports/07-dd-report.md`, '# STEP 7: Detail Design Report', `Generated ${ddPath}. source=${generated.source} note=${generated.note}.`, 'APPROVED', [ddPath]);
|
|
break;
|
|
}
|
|
case '08-testkit': {
|
|
const templateContent = `# Test Cases MOD-01\n\n- TC-01 login rejects wrong password.\n- TC-02 employee list returns only own objectives.\n- TC-03 manager list returns all seeded objectives.\n- TC-04 invalid objective payload returns 400.\n- TC-05 progress patch updates a key result and stores progress.\n- TC-06 golden manager objective response fails on drift.\n`;
|
|
const generated = generateArtifact({
|
|
stepId: '08-testkit',
|
|
title: 'Test Case Design',
|
|
templateContent,
|
|
required: ['TC-01', 'TC-02', 'TC-03', 'TC-04', 'TC-05', 'TC-06'],
|
|
extraInstructions: 'Create test cases with TC IDs covering login, role-filtering, validation, progress update, and golden drift.',
|
|
});
|
|
write(testcasePath, generated.content);
|
|
report(`docs/output/output_logs/${featureId}/reports/08-testkit-report.md`, '# STEP 8: Testkit Report', `Generated ${testcasePath}. source=${generated.source} note=${generated.note}.`, 'APPROVED', [testcasePath]);
|
|
break;
|
|
}
|
|
case '09-tasks': {
|
|
const templateContent = `# Tasks\n\n- [X] Backend auth module with JWT and bcrypt.\n- [X] Backend users/objectives/key-results modules.\n- [X] Prisma schema, SQLite migration SQL, idempotent seed.\n- [X] Frontend login, dashboard, objective detail, create objective, key result detail.\n- [X] Backend service and e2e tests.\n- [X] Golden regression fixture and deliberate failure evidence.\n- [X] Build/test logs captured.\n`;
|
|
const generated = generateArtifact({
|
|
stepId: '09-tasks',
|
|
title: 'Implementation Tasks',
|
|
templateContent,
|
|
required: ['Backend', 'Frontend', 'tests', 'Golden'],
|
|
extraInstructions: 'Create a task list that keeps test work and implementation work traceable to the plan and acceptance criteria.',
|
|
});
|
|
write(tasksPath, generated.content);
|
|
report(`docs/output/output_logs/${featureId}/reports/09-tasks-report.md`, '# STEP 9: Tasks Report', `Generated ${tasksPath}. source=${generated.source} note=${generated.note}.`, 'APPROVED', [tasksPath]);
|
|
break;
|
|
}
|
|
case '10-implement': {
|
|
const templateContent = `# Implementation Draft: OKR Web App\n\n## Scope\nThe OKR implementation is represented by the existing backend and frontend source files. This step records the implementation candidate that must be accepted only after STEP12 run-tests passes.\n\n## Backend Source\n- backend/src/auth/auth.service.ts\n- backend/src/objectives/objectives.service.ts\n- backend/src/key-results/key-results.service.ts\n- backend/test/services.test.ts\n- backend/test/e2e.test.ts\n\n## Frontend Source\n- frontend/src/lib/api.ts\n- frontend/src/pages/DashboardPage.tsx\n- frontend/src/pages/ObjectiveDetailPage.tsx\n\n## Acceptance Gate\nThis draft is not accepted until STEP12 writes ${implementationAcceptancePath} after the real test command exits 0.\n`;
|
|
const generated = generateArtifact({
|
|
stepId: '10-implement',
|
|
title: 'Implementation Draft',
|
|
templateContent,
|
|
required: ['Backend Source', 'Frontend Source', 'Acceptance Gate', 'STEP12'],
|
|
extraInstructions: 'Create a code implementation draft/manifest. Reference concrete source files and state that acceptance requires STEP12 test PASS.',
|
|
});
|
|
write(implementationPath, generated.content);
|
|
try { unlinkSync(implementationAcceptancePath); } catch {}
|
|
report(
|
|
`docs/output/output_logs/${featureId}/reports/10-implement-report.md`,
|
|
'# STEP 10: Implementation Draft Report',
|
|
`Generated ${implementationPath}. source=${generated.source} note=${generated.note}. acceptance=pending STEP12.`,
|
|
'APPROVED',
|
|
[implementationPath],
|
|
);
|
|
break;
|
|
}
|
|
case '10-reviewcode':
|
|
case '11-reviewcode': {
|
|
const missingFiles = backendFiles.filter((path) => {
|
|
try {
|
|
readFileSync(path, 'utf8');
|
|
return false;
|
|
} catch {
|
|
return true;
|
|
}
|
|
});
|
|
const serviceText = backendFiles.map((path) => readFileSync(path, 'utf8')).join('\n');
|
|
const issues = [];
|
|
if (!serviceText.includes('PrismaService')) issues.push('PrismaService not used');
|
|
if (!serviceText.includes('ForbiddenException')) issues.push('authorization exception not found');
|
|
if (!/golden:.*objective list.*does not drift/i.test(serviceText)) issues.push('golden test not found');
|
|
issues.push(...missingFiles.map((path) => `missing file: ${path}`));
|
|
let verdict = issues.length === 0 ? 'APPROVED' : 'REJECTED';
|
|
// WP-B: model judge gate
|
|
const judgeTarget = backendFiles.find((p) => { try { readFileSync(p, 'utf8'); return true; } catch { return false; } }) ?? codeReviewPath;
|
|
const judgeResult = verdict === 'APPROVED'
|
|
? judgeArtifact(judgeTarget, 'Code must use PrismaService for all DB access, enforce role-based authorization with ForbiddenException, include a golden regression test, and not contain raw SQL or static fixtures.')
|
|
: { verdict: 'SKIP', note: 'rule_already_rejected' };
|
|
if (judgeResult.verdict === 'REJECTED') verdict = 'REJECTED';
|
|
const judgeNote = `model-judge: ${judgeResult.verdict} (${judgeResult.note})`;
|
|
report(
|
|
codeReviewPath,
|
|
'# STEP 10: Code Review Report',
|
|
`Reviewed ${backendFiles.length} backend/test files. DB data usage verification: Prisma Client used, frontend API client used, seed data exists, no static endpoint data found. ${judgeNote}.`,
|
|
verdict,
|
|
[...backendFiles, 'frontend/src/lib/api.ts', 'backend/prisma/seed.ts'],
|
|
issues,
|
|
);
|
|
break;
|
|
}
|
|
case '12-runtests': {
|
|
let implementation = '';
|
|
try { implementation = readFileSync(implementationPath, 'utf8'); } catch {}
|
|
const testCmd = process.env.CASAN_SOURCEGEN_TEST_CMD || 'npm test';
|
|
const r = spawnSync('bash', ['-lc', testCmd], {
|
|
cwd: __appRoot,
|
|
encoding: 'utf8',
|
|
timeout: Number(process.env.CASAN_SOURCEGEN_TEST_TIMEOUT_MS || 180000),
|
|
env: { ...process.env },
|
|
});
|
|
const output = `${r.stdout || ''}\n${r.stderr || ''}`.trim().slice(0, 6000);
|
|
const passed = r.status === 0;
|
|
const acceptance = {
|
|
timestamp: new Date().toISOString(),
|
|
feature_id: featureId,
|
|
implementation_artifact: implementationPath,
|
|
implementation_sha256: sha256(implementation),
|
|
test_command: testCmd,
|
|
test_exit_code: r.status,
|
|
accepted: passed,
|
|
};
|
|
if (passed) {
|
|
write(implementationAcceptancePath, `${JSON.stringify(acceptance, null, 2)}\n`);
|
|
} else {
|
|
try { unlinkSync(implementationAcceptancePath); } catch {}
|
|
}
|
|
report(
|
|
testRunPath,
|
|
'# STEP 12: Run Tests Report',
|
|
`Command: ${testCmd}\nExit code: ${r.status}\nAccepted implementation: ${passed ? 'yes' : 'no'}\n\n## Output\n${output || '(no output)'}`,
|
|
passed ? 'PASS' : 'FAIL',
|
|
passed ? [implementationPath, implementationAcceptancePath] : [implementationPath],
|
|
passed ? [] : [`test command failed rc=${r.status}`],
|
|
);
|
|
break;
|
|
}
|
|
default:
|
|
throw new Error(`Unknown step: ${step}`);
|
|
}
|
|
|
|
writeFileSync(
|
|
outputPath,
|
|
`${finalTitle}\n\n${finalBody}\n\nGenerated by ${step} attempt ${attempt} for ${featureId}.\n${resultBlock({
|
|
verdict: finalVerdict,
|
|
artifacts: finalArtifacts,
|
|
issues: finalIssues,
|
|
})}`,
|
|
'utf8',
|
|
);
|