@angli/unit-test-tool 0.1.0

package/dist/src/core/tools/verify-all.js

@@ -0,0 +1,75 @@
+import path from 'node:path';
+import { readCoverageSummary } from '../coverage/read-coverage-summary.js';
+export async function verifyAll(ctx) {
+    const testDirs = await detectTestDirNames(ctx);
+    ctx.logger.info(`[verify] step=test-dirs value=${testDirs.join(',')}`);
+    ctx.logger.info(`[verify] step=run status=start cmd=${ctx.commands.verifyFull}`);
+    const verifyResult = await ctx.commandRunner.run(ctx.commands.verifyFull);
+    if (verifyResult.exitCode !== 0) {
+        if (verifyResult.stdout)
+            console.log(`[verify] stdout:\n${verifyResult.stdout}`);
+        if (verifyResult.stderr)
+            console.log(`[verify] stderr:\n${verifyResult.stderr}`);
+    }
+    const ok = verifyResult.exitCode === 0;
+    const coverageSnapshot = ok ? await readCoverageSummary(ctx) : undefined;
+    const coverageValue = coverageSnapshot?.lines;
+    const coveragePassed = ok ? coverageValue !== undefined && coverageValue >= ctx.coverageTarget : false;
+    ctx.logger.info(`[verify] step=run status=done ok=${ok} exit=${verifyResult.exitCode} coverage=${coverageValue ?? 'unknown'} target=${ctx.coverageTarget}`);
+    const state = await ctx.stateStore.load();
+    const nextState = {
+        ...state,
+        phase: 'VERIFYING_FULL',
+        status: (ok ? 'running' : 'failed'),
+        lastAction: 'verify-all',
+        nextSuggestedAction: ok ? 'report' : 'manual-intervention',
+        updatedAt: ctx.clock.nowIso()
+    };
+    await ctx.stateStore.save(nextState);
+    if (ok) {
+        await ctx.eventStore.append({
+            eventType: 'verify_full_passed',
+            phase: 'VERIFYING_FULL',
+            message: `verify all passed, coverage=${coverageValue ?? 'unknown'} target=${ctx.coverageTarget}`,
+            data: { coverageSnapshot, coverageTarget: ctx.coverageTarget },
+            timestamp: ctx.clock.nowIso()
+        });
+    }
+    else {
+        await ctx.eventStore.append({
+            eventType: 'verify_full_failed',
+            phase: 'VERIFYING_FULL',
+            message: 'verify all failed',
+            data: { stderr: verifyResult.stderr },
+            timestamp: ctx.clock.nowIso()
+        });
+    }
+    return {
+        ok,
+        phase: 'VERIFYING_FULL',
+        summary: ok ? '全量验证通过。' : '全量验证失败。',
+        nextAction: ok ? 'report' : 'manual-intervention',
+        artifacts: {
+            stdout: verifyResult.stdout,
+            stderr: verifyResult.stderr
+        },
+        coveragePassed,
+        testPassed: ok,
+        coverageSnapshot
+    };
+}
+async function detectTestDirNames(ctx) {
+    if (ctx.cache.detectedTestDirNames)
+        return ctx.cache.detectedTestDirNames;
+    const configured = ctx.config.testDirNames?.filter(Boolean) ?? ['__test__', '__tests__'];
+    const jestConfigPath = path.join(ctx.projectPath, 'jest.config.js');
+    const jestConfig = await ctx.fileSystem.readText(jestConfigPath);
+    if (!jestConfig) {
+        ctx.cache.detectedTestDirNames = configured;
+        return configured;
+    }
+    const detected = configured.filter((dir) => jestConfig.includes(dir));
+    const result = detected.length > 0 ? detected : configured;
+    ctx.cache.detectedTestDirNames = result;
+    return result;
+}

package/dist/src/core/worktrees/is-git-repo.js

@@ -0,0 +1,10 @@
+import { execa } from 'execa';
+export async function isGitRepo(projectPath) {
+    try {
+        await execa('git', ['rev-parse', '--is-inside-work-tree'], { cwd: projectPath });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/logger.js

@@ -0,0 +1 @@
+export {};

package/dist/src/utils/clock.js

@@ -0,0 +1,10 @@
+export function createClock() {
+    return {
+        now() {
+            return new Date();
+        },
+        nowIso() {
+            return new Date().toISOString();
+        }
+    };
+}

package/dist/src/utils/command-runner.js

@@ -0,0 +1,18 @@
+import { execa } from 'execa';
+export function createCommandRunner(options) {
+    return {
+        async run(command, timeoutMs = 120000) {
+            const result = await execa(command, {
+                cwd: options.cwd,
+                shell: true,
+                reject: false,
+                timeout: timeoutMs
+            });
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr,
+                exitCode: result.exitCode ?? 0
+            };
+        }
+    };
+}

package/dist/src/utils/commands.js

@@ -0,0 +1,28 @@
+export function buildCommandSet(config, scripts = {}) {
+    const verifyFromScript = scripts.test ? 'npm test' : undefined;
+    const coverageScript = scripts['test:coverage'] ? 'npm run test:coverage' : undefined;
+    const lintScript = scripts.lint ? 'npm run lint' : undefined;
+    const typecheckScript = scripts.typecheck ? 'npm run typecheck' : undefined;
+    return {
+        analyzeBaseline: config.commandOverrides?.analyzeBaseline ??
+            coverageScript ??
+            'npm test -- --coverage --runInBand',
+        verifyFull: config.commandOverrides?.verifyFull ??
+            verifyFromScript ??
+            'npm test -- --runInBand',
+        incrementalTest: (targetFile) => {
+            const base = config.commandOverrides?.incrementalTest ??
+                verifyFromScript ??
+                'npm test -- --runInBand';
+            if (!targetFile) {
+                return base;
+            }
+            return `${base} ${JSON.stringify(targetFile)}`;
+        },
+        lint: config.commandOverrides?.lint ?? lintScript ?? 'npm run lint',
+        typecheck: config.commandOverrides?.typecheck ??
+            typecheckScript ??
+            'npx tsc -p tsconfig.json --noEmit',
+        format: config.commandOverrides?.format ?? 'npm run lint'
+    };
+}

package/dist/src/utils/duration.js

@@ -0,0 +1,22 @@
+export function parseDuration(input) {
+    const trimmed = input.trim();
+    if (!trimmed)
+        return undefined;
+    const match = trimmed.match(/^(\d+)(ms|s|m|h)?$/);
+    if (!match)
+        return undefined;
+    const value = Number(match[1]);
+    const unit = match[2] ?? 'ms';
+    switch (unit) {
+        case 'ms':
+            return value;
+        case 's':
+            return value * 1000;
+        case 'm':
+            return value * 60 * 1000;
+        case 'h':
+            return value * 60 * 60 * 1000;
+        default:
+            return undefined;
+    }
+}

package/dist/src/utils/fs.js

@@ -0,0 +1,53 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+export function createFileSystem() {
+    return {
+        async ensureDir(dirPath) {
+            await fs.mkdir(dirPath, { recursive: true });
+        },
+        async fileExists(filePath) {
+            try {
+                await fs.access(filePath);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        async readJson(filePath) {
+            const exists = await this.fileExists(filePath);
+            if (!exists)
+                return undefined;
+            const content = await fs.readFile(filePath, 'utf8');
+            return JSON.parse(content);
+        },
+        async writeJson(filePath, value) {
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+        },
+        async appendLine(filePath, line) {
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            await fs.appendFile(filePath, `${line}\n`, 'utf8');
+        },
+        async appendText(filePath, content) {
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            await fs.appendFile(filePath, content, 'utf8');
+        },
+        async readText(filePath) {
+            const exists = await this.fileExists(filePath);
+            if (!exists)
+                return undefined;
+            return fs.readFile(filePath, 'utf8');
+        },
+        async writeText(filePath, content) {
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            await fs.writeFile(filePath, content, 'utf8');
+        },
+        async readDir(dirPath) {
+            const exists = await this.fileExists(dirPath);
+            if (!exists)
+                return [];
+            return fs.readdir(dirPath);
+        }
+    };
+}

package/dist/src/utils/logger.js

@@ -0,0 +1,10 @@
+import pino from 'pino';
+export function createLogger(level) {
+    const logger = pino({ level });
+    return {
+        info: (message, meta) => logger.info(meta ?? {}, message),
+        warn: (message, meta) => logger.warn(meta ?? {}, message),
+        error: (message, meta) => logger.error(meta ?? {}, message),
+        debug: (message, meta) => logger.debug(meta ?? {}, message)
+    };
+}

package/dist/src/utils/paths.js

@@ -0,0 +1,21 @@
+import path from 'node:path';
+export function buildPaths(projectPath) {
+    const runtimeDir = path.join(projectPath, '.unit_test_tool_workspace');
+    const logsPath = path.join(runtimeDir, 'logs');
+    const promptsDir = path.join(runtimeDir, 'prompts');
+    const promptRunsDir = path.join(runtimeDir, 'prompt-runs');
+    const reportsDir = path.join(runtimeDir, 'reports');
+    return {
+        runtimeDir,
+        configPath: path.join(runtimeDir, 'config.json'),
+        statePath: path.join(runtimeDir, 'state.json'),
+        logsPath,
+        promptsDir,
+        promptRunsDir,
+        eventsPath: path.join(logsPath, 'events.jsonl'),
+        reportsDir,
+        coverageSummaryPath: path.join(reportsDir, 'coverage-summary.json'),
+        finalReportPath: path.join(reportsDir, 'final-report.json'),
+        lifecyclePath: path.join(runtimeDir, 'lifecycle.json')
+    };
+}

package/dist/src/utils/process-lifecycle.js

@@ -0,0 +1,74 @@
+const DEFAULT_HEARTBEAT_INTERVAL_MS = 30_000;
+export async function startLifecycle(ctx, options) {
+    const startedAt = ctx.clock.nowIso();
+    const lifecycle = {
+        runId: ctx.runId,
+        command: options.command,
+        pid: process.pid,
+        argv: options.argv,
+        startedAt,
+        lastHeartbeat: startedAt,
+        status: 'running',
+        restartCount: 0,
+        updatedAt: startedAt
+    };
+    await ctx.lifecycleStore.save(lifecycle);
+    await ctx.eventStore.append({
+        eventType: 'lifecycle_started',
+        phase: 'INIT',
+        message: `${options.command} started`,
+        data: { pid: process.pid, argv: options.argv },
+        timestamp: startedAt
+    });
+    const interval = setInterval(async () => {
+        const now = ctx.clock.nowIso();
+        await ctx.lifecycleStore.patch({
+            lastHeartbeat: now,
+            updatedAt: now
+        });
+    }, options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS);
+    const stop = async (status, exitCode, lastError) => {
+        clearInterval(interval);
+        const now = ctx.clock.nowIso();
+        await ctx.lifecycleStore.patch({
+            status,
+            exitCode,
+            lastError,
+            updatedAt: now
+        });
+        await ctx.eventStore.append({
+            eventType: 'lifecycle_stopped',
+            phase: 'DONE',
+            message: `${options.command} ${status}`,
+            data: { exitCode, lastError },
+            timestamp: now
+        });
+    };
+    const handleExit = async (code) => {
+        await stop(code === 0 ? 'exited' : 'crashed', code);
+    };
+    const handleSignal = async (signal) => {
+        await stop('exited', undefined, `signal:${signal}`);
+        process.exit(0);
+    };
+    const handleError = async (error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        await stop('crashed', 1, message);
+        process.exit(1);
+    };
+    process.on('exit', handleExit);
+    process.on('SIGINT', handleSignal);
+    process.on('SIGTERM', handleSignal);
+    process.on('uncaughtException', handleError);
+    process.on('unhandledRejection', handleError);
+    return {
+        stop: async () => {
+            process.off('exit', handleExit);
+            process.off('SIGINT', handleSignal);
+            process.off('SIGTERM', handleSignal);
+            process.off('uncaughtException', handleError);
+            process.off('unhandledRejection', handleError);
+            await stop('exited', 0);
+        }
+    };
+}

package/dist/src/utils/prompts.js

@@ -0,0 +1,20 @@
+import { buildSystemPrompt } from '../core/prompts/system-prompt.js';
+import { buildTaskPrompt } from '../core/prompts/task-prompt.js';
+import { buildRetryPrompt } from '../core/prompts/retry-prompt.js';
+import { buildEditBoundaryPrompt } from '../core/prompts/edit-boundary-prompt.js';
+export function buildPromptBuilders(overrides) {
+    return {
+        buildSystemPrompt() {
+            return buildSystemPrompt(overrides);
+        },
+        buildTaskPrompt(task) {
+            return buildTaskPrompt(task, overrides);
+        },
+        buildRetryPrompt(task, failure) {
+            return buildRetryPrompt(task, failure, overrides);
+        },
+        buildEditBoundaryPrompt(task) {
+            return buildEditBoundaryPrompt(task);
+        }
+    };
+}

package/dist/tests/core/create-context.test.js

@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { createContext } from '../../src/cli/context/create-context.js';
+describe('createContext', () => {
+    it('passes promptOverrides into prompt builders', async () => {
+        const projectPath = mkdtempSync(path.join(os.tmpdir(), 'unit-test-tool-'));
+        try {
+            writeFileSync(path.join(projectPath, 'package.json'), JSON.stringify({ scripts: {} }));
+            const ctx = await createContext({
+                projectPath,
+                coverageTarget: 80,
+                configOverrides: {
+                    promptOverrides: {
+                        systemAppend: 'system override',
+                        taskAppend: 'task override',
+                        retryAppend: 'retry override'
+                    }
+                }
+            });
+            const task = {
+                taskId: 't1',
+                targetFile: 'src/foo.ts',
+                testFiles: [],
+                score: 1,
+                reasons: [],
+                estimatedDifficulty: 'low',
+                strategy: '补测试',
+                status: 'pending',
+                attemptCount: 0
+            };
+            expect(ctx.prompts.buildSystemPrompt()).toContain('system override');
+            expect(ctx.prompts.buildTaskPrompt(task)).toContain('task override');
+            expect(ctx.prompts.buildRetryPrompt(task, 'failed')).toContain('retry override');
+        }
+        finally {
+            rmSync(projectPath, { recursive: true, force: true });
+        }
+    });
+});

package/dist/tests/core/default-state.test.js

@@ -0,0 +1,10 @@
+import { describe, expect, it } from 'vitest';
+import { defaultState } from '../../src/core/storage/defaults.js';
+describe('defaultState', () => {
+    it('provides baseline state', () => {
+        const state = defaultState();
+        expect(state.phase).toBe('INIT');
+        expect(state.status).toBe('idle');
+        expect(state.totals.pending).toBe(0);
+    });
+});

package/dist/tests/core/failure-classification.test.js

@@ -0,0 +1,7 @@
+import { describe, expect, it } from 'vitest';
+import { classifyFailure } from '../../src/core/strategies/classify-failure.js';
+describe('classifyFailure', () => {
+    it('classifies timeout messages', () => {
+        expect(classifyFailure('request timeout')).toBe('CLI_TIMEOUT');
+    });
+});

package/dist/tests/core/loop-detection.test.js

@@ -0,0 +1,7 @@
+import { describe, expect, it } from 'vitest';
+import { loopDetection } from '../../src/core/middleware/loop-detection.js';
+describe('loopDetection', () => {
+    it('detects when threshold exceeded', () => {
+        expect(loopDetection({ attemptCount: 3 }, 2).loopDetected).toBe(true);
+    });
+});

package/dist/tests/core/paths.test.js

@@ -0,0 +1,11 @@
+import { describe, expect, it } from 'vitest';
+import { buildPaths } from '../../src/utils/paths.js';
+describe('buildPaths', () => {
+    it('builds runtime file paths', () => {
+        const paths = buildPaths('/tmp/demo-project');
+        expect(paths.runtimeDir).toBe('/tmp/demo-project/.unit_test_tool_workspace');
+        expect(paths.statePath).toBe('/tmp/demo-project/.unit_test_tool_workspace/state.json');
+        expect(paths.eventsPath).toBe('/tmp/demo-project/.unit_test_tool_workspace/logs/events.jsonl');
+        expect(paths.finalReportPath).toBe('/tmp/demo-project/.unit_test_tool_workspace/reports/final-report.json');
+    });
+});

package/dist/tests/core/prompt-builders.test.js

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { buildPromptBuilders } from '../../src/utils/prompts.js';
+describe('buildPromptBuilders', () => {
+    it('includes default strategy and case library in system prompt', () => {
+        const prompts = buildPromptBuilders();
+        const systemPrompt = prompts.buildSystemPrompt();
+        expect(systemPrompt).toContain('通用单测策略：');
+        expect(systemPrompt).toContain('典型案例约束：');
+        expect(systemPrompt).toContain('render/HOC 包装组件');
+        expect(systemPrompt).toContain('强依赖上下文组件');
+    });
+    it('appends project prompt overrides', () => {
+        const prompts = buildPromptBuilders({
+            systemAppend: 'system rule',
+            taskAppend: 'task rule',
+            retryAppend: 'retry rule'
+        });
+        const task = {
+            taskId: 't1',
+            targetFile: 'src/foo.ts',
+            testFiles: [],
+            score: 1,
+            reasons: [],
+            estimatedDifficulty: 'low',
+            strategy: '补测试',
+            status: 'pending',
+            attemptCount: 0
+        };
+        expect(prompts.buildSystemPrompt()).toContain('system rule');
+        expect(prompts.buildTaskPrompt(task)).toContain('task rule');
+        expect(prompts.buildRetryPrompt(task, 'boom')).toContain('retry rule');
+    });
+});

package/dist/tests/core/score-candidate.test.js

@@ -0,0 +1,28 @@
+import { describe, expect, it } from 'vitest';
+import { scoreCandidate } from '../../src/core/planner/score-candidate.js';
+describe('scoreCandidate', () => {
+    it('scores priority and low complexity candidates higher', () => {
+        const result = scoreCandidate({
+            targetFile: 'src/a.ts',
+            coverage: { coverageGap: 20 },
+            pathPriority: { label: 'priority', score: 100 },
+            fileClassification: {},
+            dependencyComplexity: {
+                importCount: 1,
+                externalDependencyCount: 1,
+                complexityLevel: 'low'
+            },
+            existingTest: {
+                hasExistingTest: false,
+                testFilePaths: []
+            },
+            failureHistory: {
+                previousAttemptCount: 0,
+                loopDetected: false,
+                blockedBefore: false,
+                failurePenaltyScore: 0
+            }
+        });
+        expect(result.baseScore).toBeGreaterThan(100);
+    });
+});

package/dist/tests/core/state-machine.test.js

@@ -0,0 +1,12 @@
+import { describe, expect, it } from 'vitest';
+import { deriveStatusFromPhase } from '../../src/core/state-machine/index.js';
+describe('deriveStatusFromPhase', () => {
+    it('maps blocked and done phases', () => {
+        expect(deriveStatusFromPhase('BLOCKED')).toBe('blocked');
+        expect(deriveStatusFromPhase('DONE')).toBe('done');
+    });
+    it('maps init to idle and active phases to running', () => {
+        expect(deriveStatusFromPhase('INIT')).toBe('idle');
+        expect(deriveStatusFromPhase('WRITING_TESTS')).toBe('running');
+    });
+});

package/dist/tests/integration/status-report.test.js

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest';
+import path from 'node:path';
+import { createContext } from '../../src/cli/context/create-context.js';
+import { analyzeBaseline } from '../../src/core/tools/analyze-baseline.js';
+import { buildFinalReport, reportStatus } from '../../src/core/reporter/index.js';
+const fixture = path.resolve('tests/fixtures/simple-project');
+describe('integration: status/report', () => {
+    it('builds status and report', async () => {
+        const ctx = await createContext({
+            projectPath: fixture,
+            coverageTarget: 80
+        });
+        await analyzeBaseline(ctx);
+        const status = await reportStatus(ctx);
+        expect(status.ok).toBe(true);
+        const report = await buildFinalReport(ctx);
+        await ctx.reportStore.saveFinalReport(report);
+        const loaded = await ctx.reportStore.loadFinalReport();
+        expect(loaded).toBeTruthy();
+    });
+});

package/docs/architecture.md

@@ -0,0 +1,20 @@
+# 架构概览
+
+本工具采用 **Claude CLI-first** 的轻量架构：
+
+1. **Core 层**：提供仓库扫描、候选筛选、命令探测、验证与报告等能力。
+2. **CLI 层**：作为薄适配层，解析参数、构造上下文并触发 Claude CLI。
+
+核心原则：
+- 以 Claude CLI 直接在工作区补测为主；本工具只提供辅助与校验
+- 规则筛选替代重编排与多轮状态机
+- 命令与结果保持简洁、可读、可复用
+
+关键路径：
+- analyze/recommend → run → verify → status/report
+
+目录约定：
+- `src/core/`：核心能力
+- `src/cli/`：命令入口
+- `src/types/`：类型与协议
+- `src/utils/`：工具层