@kkeve/suite 0.0.1 → 0.0.2

package/dist/commands/init.js

@@ -0,0 +1,292 @@
+"use strict";
+/**
+ * keve init - Initialize .keve/ directory and inject Skills
+ *
+ * Creates the .keve/ workspace, Playwright infrastructure,
+ * and copies keve skills into .codeflicker/skills/.
+ *
+ * Note: keveAssert is exported directly from @ks-data/keve-suite (import { keveAssert } from '@ks-data/keve-suite')
+ * — no file needs to be written to the project.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const chalk_1 = __importDefault(require("chalk"));
+const pw_config_1 = require("../core/pw-config");
+// Skills bundled in this package — copied to global ~/.codeflicker/skills/
+const KEVE_SKILLS = [
+    'keve-bddcase-gen',
+    'keve-e2e-gen',
+    'keve-test-eval',
+    'keve-static-analysis',
+    'keve-unit-gen',
+    'keve-component-gen',
+];
+// Agents bundled in this package — copied to global ~/.codeflicker/agents/
+const KEVE_AGENTS = [
+    'keve-test-agent',
+    'keve-dev-test-agent',
+];
+const KEVE_YAML_TEMPLATE = `# ━━━ 目录结构规范（Single Source of Truth）━━━━━━━━━━━━━━━━━
+# 输入端 → keve_test_spec/（跨 MR 共享，项目长期资产，git tracked）
+#   keve.yaml              ← 本文件（全局配置 + 目录约定）
+#   keve-test.config.ts    ← Playwright 配置
+#   vitest.config.ts       ← Vitest 配置
+#   e2e/poms/              ← POM 类
+#   e2e/locator-catalog.json ← 定位器目录
+#   e2e/__test__/           ← E2E 测试脚本 *.spec.ts
+#   component/models/       ← 组件行为模型 *.model.ts（场景+Props+断言，即组件 fixture）
+#   component/__test__/     ← 组件测试脚本 *.test.ts（引用 model）
+#   component/registry.json ← 组件注册表
+#   component/coverage.yaml ← 组件测试覆盖索引
+#   util/__test__/          ← 单元测试脚本 *.test.ts
+# 输出端 → .keve/（执行产物，gitignored）
+#   coverage/              ← vitest --coverage 报告（HTML/JSON）
+#   analysis-report.yaml    ← 静态分析结果
+#   analysis-report.html    ← 静态分析可视化报告
+#   test-plan.yaml          ← 全流程进度追踪
+# MR 级模块 → .keve/{branch}/
+#   test-cases.yaml        ← BDD 用例定义
+#   test-artifacts/        ← E2E 执行产物（round-N/, latest/, confidence-data.jsonl）
+# {MR_ID} 替换规则：KEVE_TASK_DIR=.keve/MR123 或默认 .keve/current
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+project:
+  name: ''              # 项目名称
+
+state:
+  current_round: 0
+  # last_run_at: auto
+
+llm:
+  model: app-xxx
+  base_url: https://xxx
+  # api_key: from env KEVE_LLM_API_KEY
+
+keveAPI: https://xxx
+openAPI: https://xxx
+
+execution:
+  timeout_ms: 1200000
+  retries: 0
+  reporter: json
+  screenshot: only-on-failure
+`;
+const VITEST_CONFIG_TEMPLATE = `import { defineConfig } from 'vitest/config';
+import vue from '@vitejs/plugin-vue';
+import * as path from 'node:path';
+
+const projectRoot = path.resolve(__dirname, '..');
+
+// Shared resolve config — applied to all projects
+const sharedResolve = {
+  alias: {
+    '@': path.resolve(projectRoot, 'src'),
+    '@/keve_test_spec': path.resolve(projectRoot, 'keve_test_spec'),
+  },
+};
+
+export default defineConfig({
+  plugins: [vue()],
+  resolve: sharedResolve,
+  test: {
+    // Multi-project: unit (node) + component (jsdom)
+    projects: [
+      {
+        resolve: sharedResolve,
+        plugins: [vue()],
+        test: {
+          name: 'unit',
+          environment: 'node',
+          include: ['keve_test_spec/util/__test__/**/*.test.ts'],
+        },
+      },
+      {
+        resolve: sharedResolve,
+        plugins: [vue()],
+        test: {
+          name: 'component',
+          environment: 'jsdom',
+          include: ['keve_test_spec/component/__test__/**/*.test.ts'],
+          setupFiles: [],
+        },
+      },
+    ],
+    coverage: {
+      provider: 'v8',
+      reporter: ['json', 'text', 'html'],
+      reportsDirectory: path.join(projectRoot, '.keve', 'coverage'),
+      include: ['src/utils/**', 'src/hooks/**', 'src/composables/**', 'src/components/**'],
+    },
+  },
+});
+`;
+function copyDirRecursive(src, dest) {
+    if (!fs.existsSync(dest))
+        fs.mkdirSync(dest, { recursive: true });
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirRecursive(srcPath, destPath);
+        }
+        else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+async function init(options) {
+    const cwd = process.cwd();
+    const keveDir = path.join(cwd, '.keve');
+    console.log(chalk_1.default.cyan('\n🔧 keve init\n'));
+    // Check if .keve already exists
+    if (fs.existsSync(keveDir) && !options.force) {
+        console.log(chalk_1.default.yellow('  ⚠ .keve/ already exists. Use --force to overwrite.'));
+        console.log(chalk_1.default.gray('    Existing config preserved.'));
+    }
+    // Create directories — shared modules in project root, MR-specific under .keve/
+    const dirs = [
+        keveDir,
+        // Shared: keve_test_spec/ (cross-MR, long-term assets)
+        path.join(cwd, 'keve_test_spec'),
+        // E2E
+        path.join(cwd, 'keve_test_spec', 'e2e', 'poms'),
+        path.join(cwd, 'keve_test_spec', 'e2e', '__test__'),
+        // Component
+        path.join(cwd, 'keve_test_spec', 'component', 'models'),
+        path.join(cwd, 'keve_test_spec', 'component', '__test__'),
+        // Unit
+        path.join(cwd, 'keve_test_spec', 'util', '__test__'),
+    ];
+    for (const dir of dirs) {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+            console.log(chalk_1.default.gray(`  Created: ${path.relative(cwd, dir)}`));
+        }
+        else {
+            console.log(chalk_1.default.gray(`  Exists:  ${path.relative(cwd, dir)}`));
+        }
+    }
+    // Copy keve skills into global ~/.codeflicker/skills/
+    // Skills live in <package-root>/doc/skills/ (sibling of dist/)
+    // __dirname points to dist/commands/, so go up 2 levels to package root
+    const packageRoot = path.resolve(__dirname, '..', '..');
+    const skillsSourceDir = path.join(packageRoot, 'doc/skills');
+    const skillsTargetDir = path.join(cwd, '.codeflicker', 'skills');
+    for (const skillName of KEVE_SKILLS) {
+        const srcDir = path.join(skillsSourceDir, skillName);
+        const destDir = path.join(skillsTargetDir, skillName);
+        if (!fs.existsSync(srcDir)) {
+            console.log(chalk_1.default.yellow(`  ⚠ Skill source not found: ${skillName} (skipping)`));
+            continue;
+        }
+        // Copy entire skill directory recursively
+        copyDirRecursive(srcDir, destDir);
+        console.log(chalk_1.default.green(`  ✓ Installed Skill: ${skillName}`));
+    }
+    // Copy keve agents into global ~/.codeflicker/agents/
+    const agentsSourceDir = path.join(packageRoot, 'doc/agents');
+    const agentsTargetDir = path.join(os.homedir(), '.codeflicker', 'agents');
+    for (const agentName of KEVE_AGENTS) {
+        const srcFile = path.join(agentsSourceDir, `${agentName}.md`);
+        const destFile = path.join(agentsTargetDir, `${agentName}.md`);
+        if (!fs.existsSync(srcFile)) {
+            console.log(chalk_1.default.yellow(`  ⚠ Agent source not found: ${agentName} (skipping)`));
+            continue;
+        }
+        fs.mkdirSync(agentsTargetDir, { recursive: true });
+        fs.copyFileSync(srcFile, destFile);
+        console.log(chalk_1.default.green(`  ✓ Installed Agent: ${agentName}`));
+    }
+    // Write keve.yaml(with directory spec comments)
+    const keveYamlPath = path.join(cwd, 'keve_test_spec', 'keve.yaml');
+    if (!fs.existsSync(keveYamlPath) || options.force) {
+        fs.writeFileSync(keveYamlPath, KEVE_YAML_TEMPLATE, 'utf-8');
+        console.log(chalk_1.default.green('  ✓ Created keve.yaml (with directory spec)'));
+    }
+    else {
+        console.log(chalk_1.default.gray('  Exists:  keve.yaml (preserved)'));
+    }
+    // Write Playwright config
+    const pwConfigPath = path.join(cwd, 'keve_test_spec', 'keve-test.config.ts');
+    const pwOptions = {
+        baseUrl: options.baseUrl || process.env.BASE_URL || process.env.PWGEN_TARGET_URL,
+        cdp: options.cdp,
+        webServer: !options.cdp,
+    };
+    if (!fs.existsSync(pwConfigPath) || options.force) {
+        fs.writeFileSync(pwConfigPath, (0, pw_config_1.generatePwConfig)(pwOptions), 'utf-8');
+        console.log(chalk_1.default.green('  ✓ Created keve-test.config.ts'));
+        console.log(chalk_1.default.gray(`    baseURL: ${pwOptions.baseUrl || '(from env)'}`));
+        console.log(chalk_1.default.gray(`    CDP:     ${pwOptions.cdp ? 'enabled' : 'disabled'}`));
+    }
+    else {
+        const existingContent = fs.readFileSync(pwConfigPath, 'utf-8');
+        if (!existingContent.includes('keve-report') && !existingContent.includes('KeveReporter')) {
+            console.log(chalk_1.default.yellow('  ⚠ keve-test.config.ts exists but missing KeveReporter'));
+            console.log(chalk_1.default.gray('    Run: keve config --force  to regenerate'));
+        }
+        else {
+            console.log(chalk_1.default.gray('  Exists:  keve-test.config.ts (preserved)'));
+        }
+    }
+    // Write Vitest config
+    const vitestConfigPath = path.join(cwd, 'keve_test_spec', 'vitest.config.ts');
+    if (!fs.existsSync(vitestConfigPath) || options.force) {
+        fs.writeFileSync(vitestConfigPath, VITEST_CONFIG_TEMPLATE, 'utf-8');
+        console.log(chalk_1.default.green('  ✓ Created vitest.config.ts'));
+    }
+    else {
+        console.log(chalk_1.default.gray('  Exists:  vitest.config.ts (preserved)'));
+    }
+    // Note: keveAssert is exported from @ks-data/keve-suite directly
+    // No file needs to be written — users import it:
+    //   import { keveAssert } from '@ks-data/keve-suite';
+    console.log(chalk_1.default.gray('  ⓘ keveAssert available via: import { keveAssert } from "@ks-data/keve-suite"'));
+    console.log(chalk_1.default.green('\n  ✓ keve init complete'));
+    console.log(chalk_1.default.gray('\n  Next steps:'));
+    console.log(chalk_1.default.gray('    1. keve dev-test    — 静态分析 + 单测 + 组件测试（开发阶段）'));
+    console.log(chalk_1.default.gray('    2. keve bddcase     — 生成 BDD 测试用例'));
+    console.log(chalk_1.default.gray('    3. keve e2e-gen     — 生成 Playwright E2E 脚本'));
+    console.log(chalk_1.default.gray('    4. keve run         — 执行 E2E + 评估 + 报告'));
+    console.log(chalk_1.default.gray('    5. npx playwright install  — 安装 Playwright 浏览器（首次）\n'));
+}

package/dist/commands/report.d.ts

@@ -0,0 +1,12 @@
+/**
+ * keve report - Generate report-data.json
+ *
+ * Usually called automatically by `keve run` after test execution.
+ * Only generates report-data.json — frontend Vue report page consumes this.
+ */
+export interface ReportOptions {
+    results?: string;
+    cases?: string;
+    round?: string;
+}
+export declare function report(options: ReportOptions): Promise<void>;

package/dist/commands/report.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * keve report - Generate report-data.json
+ *
+ * Usually called automatically by `keve run` after test execution.
+ * Only generates report-data.json — frontend Vue report page consumes this.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.report = report;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../config");
+const index_1 = require("../index");
+/**
+ * Resolve paths for report inputs
+ */
+function resolvePaths(options) {
+    const keveDir = (0, config_1.findKeveDir)();
+    // Determine round
+    let round = null;
+    if (options.round) {
+        round = parseInt(options.round, 10);
+    }
+    else if (keveDir) {
+        const branchDir = (0, config_1.getBranchDir)(keveDir);
+        const artifactsBase = branchDir ? path.join(branchDir, 'test-artifacts') : path.join(keveDir, 'test-artifacts');
+        if (fs.existsSync(artifactsBase)) {
+            const dirs = fs.readdirSync(artifactsBase)
+                .filter(d => d.startsWith('round-'))
+                .map(d => parseInt(d.replace('round-', ''), 10))
+                .filter(n => !isNaN(n));
+            if (dirs.length > 0)
+                round = Math.max(...dirs);
+        }
+    }
+    // Resolve test-results.json
+    let resultsPath = options.results;
+    if (!resultsPath && keveDir && round !== null) {
+        const branchDir = (0, config_1.getBranchDir)(keveDir);
+        const resultBase = branchDir ? path.join(branchDir, 'test-artifacts', `round-${round}`) : path.join(keveDir, 'test-artifacts', `round-${round}`);
+        const candidate = path.join(resultBase, 'test-results.json');
+        if (fs.existsSync(candidate))
+            resultsPath = candidate;
+    }
+    // Resolve test-cases.yaml
+    let casesPath = options.cases;
+    if (!casesPath && keveDir) {
+        const candidates = [
+            path.join(keveDir, 'test-cases.yaml'),
+            path.join(process.cwd(), 'keve_test_spec', 'test-cases.yaml'),
+        ];
+        for (const c of candidates) {
+            if (fs.existsSync(c)) {
+                casesPath = c;
+                break;
+            }
+        }
+    }
+    // Resolve confidence-data.jsonl
+    let confidencePath = '';
+    if (keveDir && round !== null) {
+        const branchDir = (0, config_1.getBranchDir)(keveDir);
+        const resultBase = branchDir ? path.join(branchDir, 'test-artifacts', `round-${round}`) : path.join(keveDir, 'test-artifacts', `round-${round}`);
+        const candidate = path.join(resultBase, 'confidence-data.jsonl');
+        if (fs.existsSync(candidate))
+            confidencePath = candidate;
+    }
+    return { resultsPath, casesPath, confidencePath, round, keveDir };
+}
+/**
+ * Generate report-data.json only
+ */
+async function invokeReport(options) {
+    const { resultsPath, casesPath, confidencePath, keveDir } = resolvePaths(options);
+    if (!resultsPath || !fs.existsSync(resultsPath)) {
+        console.error(chalk_1.default.red('  ✗ test-results.json not found'));
+        console.error(chalk_1.default.gray(`    Use --results to specify path`));
+        process.exit(1);
+    }
+    const projectRoot = keveDir || path.dirname(resultsPath);
+    console.log(chalk_1.default.cyan('\n📊 keve report\n'));
+    try {
+        const reportData = await (0, index_1.generateReportData)({
+            projectRoot,
+            resultsPath,
+            confidencePath: confidencePath || undefined,
+            casesPath: casesPath || undefined,
+        });
+        const roundDir = reportData.roundDir;
+        const latestDir = reportData.latestDir;
+        fs.mkdirSync(roundDir, { recursive: true });
+        // 只写 round-N/report-data.json
+        const json = JSON.stringify(reportData, null, 2);
+        fs.writeFileSync(path.join(roundDir, 'report-data.json'), json);
+        // latest → round-N symlink
+        try {
+            if (fs.existsSync(latestDir)) {
+                const stat = fs.lstatSync(latestDir);
+                if (stat.isSymbolicLink()) {
+                    fs.unlinkSync(latestDir);
+                }
+                else {
+                    fs.rmSync(latestDir, { recursive: true, force: true });
+                }
+            }
+            fs.symlinkSync(path.basename(roundDir), latestDir, 'junction');
+        }
+        catch { /* ignore latest symlink error */ }
+        const summaryInner = reportData.summary?.summary || reportData.summary;
+        console.log(chalk_1.default.green(`  ✓ report-data.json generated at ${path.relative(process.cwd(), path.join(roundDir, 'report-data.json'))}`));
+        console.log(`    Total: ${summaryInner.total} | Passed: ${summaryInner.passed} | Failed: ${summaryInner.failed}`);
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(`  ✗ Report generation failed: ${err.message}`));
+        if (process.env.KEVE_VERBOSE)
+            console.error(err);
+        process.exit(1);
+    }
+}
+async function report(options) {
+    await invokeReport(options);
+}

package/dist/commands/run.d.ts

@@ -0,0 +1,29 @@
+/**
+ * keve run - Execute Playwright tests
+ *
+ * Wraps `npx playwright test` with round management and output organization.
+ * Does NOT hardcode reporter or resultDir — the Playwright config handles those.
+ * Only adds: round number management, retry-from/cases filtering, and post-run report generation.
+ */
+export interface RunOptions {
+    config?: string;
+    round?: string;
+    retryFrom?: string;
+    cases?: string;
+    grep?: string;
+    verbose?: boolean;
+}
+export interface RunResult {
+    exitCode: number;
+    resultsFile: string;
+    resultDir: string;
+    taskDir: string;
+    round: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+}
+export declare class KeveRunError extends Error {
+    constructor(message: string);
+}
+export declare function run(options: RunOptions): Promise<RunResult>;