@kkeve/suite 0.0.1 → 0.0.3

package/dist/commands/vitest.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * keve vitest - Execute Vitest unit/component tests
+ *
+ * Wraps `npx vitest` with keve-specific config and coverage support.
+ * Uses vitest.config.ts from keve_test_spec/ by default.
+ */
+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.vitest = vitest;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Walk up from __dirname to find node_modules/vitest/vitest.mjs
+ *
+ * pnpm structure:
+ *   node_modules/.pnpm/@ks-data+keve-agent@.../node_modules/
+ *     ├── @ks-data/keve-suite/    ← __dirname is in dist/commands/ here
+ *     └── vitest/                 ← sibling dep, walk up to find
+ *
+ * npm/node structure:
+ *   node_modules/
+ *     ├── @ks-data/keve-suite/    ← __dirname is in dist/commands/ here
+ *     └── vitest/                 ← sibling dep, walk up to find
+ */
+function findVitestBinary() {
+    let current = __dirname;
+    for (let i = 0; i < 10; i++) {
+        const vitestBin = path.join(current, 'node_modules', 'vitest', 'vitest.mjs');
+        if (fs.existsSync(vitestBin)) {
+            return {
+                bin: vitestBin,
+                nodeModules: path.join(current, 'node_modules'),
+            };
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            break; // reached filesystem root
+        current = parent;
+    }
+    return null;
+}
+/**
+ * Find Vitest config: keve_test_spec/vitest.config.ts by default
+ */
+function findVitestConfig(optionsConfig) {
+    const cwd = process.cwd();
+    if (optionsConfig) {
+        const resolved = path.resolve(cwd, optionsConfig);
+        if (fs.existsSync(resolved))
+            return resolved;
+        console.error(chalk_1.default.red(`  ✗ Vitest config not found: ${optionsConfig}`));
+        return null;
+    }
+    const configPath = path.join(cwd, 'keve_test_spec', 'vitest.config.ts');
+    if (fs.existsSync(configPath))
+        return configPath;
+    console.error(chalk_1.default.red('  ✗ Vitest config not found'));
+    console.error(chalk_1.default.gray('    Searched: keve_test_spec/vitest.config.ts'));
+    console.error(chalk_1.default.gray('    Run: keve init'));
+    return null;
+}
+async function vitest(options) {
+    const cwd = process.cwd();
+    const configPath = findVitestConfig(options.config);
+    if (!configPath) {
+        process.exit(1);
+    }
+    console.log(chalk_1.default.cyan('\n🧪 keve vitest\n'));
+    // Build vitest args
+    const vitestArgs = [];
+    // Run mode (default: single run; --watch for watch mode)
+    if (options.watch) {
+        vitestArgs.push('watch');
+    }
+    else {
+        vitestArgs.push('run');
+    }
+    vitestArgs.push('--config', configPath);
+    if (options.coverage) {
+        vitestArgs.push('--coverage');
+    }
+    if (options.filter) {
+        vitestArgs.push(options.filter);
+    }
+    if (options.verbose) {
+        console.log(chalk_1.default.gray(`  Config:    ${configPath}`));
+        console.log(chalk_1.default.gray(`  Mode:      ${options.watch ? 'watch' : 'run'}`));
+        console.log(chalk_1.default.gray(`  Coverage:  ${options.coverage ? 'enabled' : 'disabled'}`));
+        console.log(chalk_1.default.gray(`  Filter:    ${options.filter || '(all)'}`));
+        console.log();
+    }
+    console.log(chalk_1.default.blue(`  ▶ Running Vitest tests...\n`));
+    // Resolve vitest binary — pnpm puts it in a sibling node_modules/
+    // Walk up from __dirname (dist/commands/) to find node_modules/vitest/
+    const vitestInfo = findVitestBinary();
+    if (!vitestInfo) {
+        console.error(chalk_1.default.red('  ✗ Vitest not found'));
+        console.error(chalk_1.default.yellow('    Install: pnpm add -D @ks-data/keve-suite (includes vitest)'));
+        process.exit(1);
+    }
+    const { bin: vitestBin, nodeModules: vitestNodeModules } = vitestInfo;
+    // Execute Vitest with NODE_PATH so vitest.config.ts can resolve 'vitest/config'
+    const exitCode = await new Promise((resolve) => {
+        const existingNodePath = process.env.NODE_PATH || '';
+        const nodePath = existingNodePath
+            ? `${vitestNodeModules}:${existingNodePath}`
+            : vitestNodeModules;
+        const child = (0, node_child_process_1.spawn)('node', [vitestBin, ...vitestArgs], {
+            cwd,
+            stdio: 'inherit',
+            env: {
+                ...process.env,
+                NODE_PATH: nodePath,
+                FORCE_COLOR: '1',
+            },
+        });
+        child.on('close', (code) => resolve(code ?? 1));
+        child.on('error', (err) => {
+            console.error(chalk_1.default.red(`  ✗ Failed to start vitest: ${err.message}`));
+            resolve(1);
+        });
+    });
+    if (exitCode !== 0) {
+        console.log(chalk_1.default.yellow('\n  ⚠ Some tests failed.'));
+        process.exit(exitCode);
+    }
+    console.log(chalk_1.default.green('\n  ✓ All Vitest tests passed.'));
+}

package/dist/config.d.ts

@@ -0,0 +1,109 @@
+/**
+ * keve config loader - reads keve_test_spec/keve.yaml
+ */
+export interface KeveConfig {
+    project: {
+        name: string;
+        prd_url?: string;
+    };
+    state: {
+        current_round: number;
+        last_run_at?: string;
+    };
+    llm: {
+        model: string;
+        base_url: string;
+        api_key?: string;
+    };
+    execution: {
+        timeout_ms: number;
+        retries: number;
+        reporter: string;
+        screenshot: string;
+    };
+    platform?: {
+        base_url?: string;
+        plan_id?: string | null;
+        teamId?: string;
+    };
+}
+/** Per-task run state — stored in .keve/{task}/run-state.yaml */
+export interface RunState {
+    current_round: number;
+    last_run_at?: string;
+    rounds: Record<number, {
+        status: 'running' | 'completed' | 'failed';
+        started_at: string;
+        completed_at?: string;
+        passed?: number;
+        failed?: number;
+        skipped?: number;
+    }>;
+}
+/**
+ * Find keve_test_spec/ directory by walking up from cwd
+ */
+export declare function findKeveDir(startDir?: string): string | null;
+/**
+ * Load keve.yaml config
+ */
+export declare function loadConfig(keveDir?: string | null): KeveConfig;
+/**
+ * Save keve.yaml config
+ */
+export declare function saveConfig(config: KeveConfig, keveDir: string): void;
+/**
+ * Get current round number, auto-increment
+ */
+export declare function getNextRound(keveDir: string): number;
+/**
+ * Resolve latest round directory
+ */
+export declare function getLatestRoundDir(keveDir: string): string | null;
+/**
+ * Get branch-specific directory under .keve/
+ * Uses current git branch name to create/find .keve/{branch}/
+ */
+export declare function getBranchDir(keveDir: string | null): string | null;
+/**
+ * Get current git branch name
+ */
+export declare function getCurrentBranch(): string | null;
+/**
+ * 获取 git 用户名
+ */
+export declare function getGitUserName(): string;
+/**
+ * 获取 git remote origin 仓库名
+ */
+export declare function getGitRepoName(): string;
+/**
+ * 获取当前 git 分支名
+ */
+export declare function getGitBranchName(): string;
+/**
+ * Resolve task directory from KEVE_TASK_DIR env or keveDir + branch.
+ * Returns absolute path to the task root (e.g. .keve/mr-868-temp).
+ */
+export declare function resolveTaskDir(keveDir: string | null): string | null;
+/**
+ * Read run-state.yaml from task directory.
+ * Returns default state if file doesn't exist.
+ */
+export declare function readRunState(taskDir: string): RunState;
+/**
+ * Write run-state.yaml to task directory.
+ */
+export declare function writeRunState(taskDir: string, state: RunState): void;
+/**
+ * Get next round number and update run-state.yaml.
+ */
+export declare function getNextRoundFromState(taskDir: string): number;
+/**
+ * Mark a round as completed with stats.
+ */
+export declare function completeRound(taskDir: string, round: number, stats: {
+    passed: number;
+    failed: number;
+    skipped: number;
+}): void;

package/dist/config.js

@@ -0,0 +1,291 @@
+"use strict";
+/**
+ * keve config loader - reads keve_test_spec/keve.yaml
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findKeveDir = findKeveDir;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.getNextRound = getNextRound;
+exports.getLatestRoundDir = getLatestRoundDir;
+exports.getBranchDir = getBranchDir;
+exports.getCurrentBranch = getCurrentBranch;
+exports.getGitUserName = getGitUserName;
+exports.getGitRepoName = getGitRepoName;
+exports.getGitBranchName = getGitBranchName;
+exports.resolveTaskDir = resolveTaskDir;
+exports.readRunState = readRunState;
+exports.writeRunState = writeRunState;
+exports.getNextRoundFromState = getNextRoundFromState;
+exports.completeRound = completeRound;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const yaml = __importStar(require("yaml"));
+const child_process_1 = require("child_process");
+const DEFAULT_CONFIG = {
+    project: {
+        name: '',
+    },
+    state: {
+        current_round: 0,
+    },
+    llm: {
+        model: process.env.KEVE_LLM_MODEL || '',
+        base_url: process.env.KEVE_LLM_BASE_URL || process.env.KONSTRUCTOR_API_BASE || '',
+        api_key: process.env.KEVE_LLM_API_KEY || process.env.LLM_API_KEY || '',
+    },
+    execution: {
+        timeout_ms: 1200000,
+        retries: 0,
+        reporter: 'json',
+        screenshot: 'only-on-failure',
+    },
+};
+/**
+ * Find keve_test_spec/ directory by walking up from cwd
+ */
+function findKeveDir(startDir) {
+    let dir = startDir || process.cwd();
+    for (let i = 0; i < 20; i++) {
+        // Prefer .keve/ directory as the canonical keve home
+        const dotKeve = path.join(dir, '.keve');
+        if (fs.existsSync(dotKeve))
+            return dotKeve;
+        // Fallback: keve_test_spec/ for legacy projects
+        const specDir = path.join(dir, 'keve_test_spec');
+        if (fs.existsSync(specDir))
+            return specDir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/**
+ * Load keve.yaml config
+ */
+function loadConfig(keveDir) {
+    const dir = keveDir || findKeveDir();
+    if (!dir)
+        return DEFAULT_CONFIG;
+    const configPath = path.join(dir, 'keve.yaml');
+    if (!fs.existsSync(configPath))
+        return DEFAULT_CONFIG;
+    const content = fs.readFileSync(configPath, 'utf-8');
+    const parsed = yaml.parse(content);
+    return { ...DEFAULT_CONFIG, ...parsed };
+}
+/**
+ * Save keve.yaml config
+ */
+function saveConfig(config, keveDir) {
+    const configPath = path.join(keveDir, 'keve.yaml');
+    const content = yaml.stringify(config, { lineWidth: 0 });
+    fs.writeFileSync(configPath, content, 'utf-8');
+}
+/**
+ * Get current round number, auto-increment
+ */
+function getNextRound(keveDir) {
+    const config = loadConfig(keveDir);
+    const next = config.state.current_round + 1;
+    config.state.current_round = next;
+    config.state.last_run_at = new Date().toISOString();
+    saveConfig(config, keveDir);
+    return next;
+}
+/**
+ * Resolve latest round directory
+ */
+function getLatestRoundDir(keveDir) {
+    const artifactsDir = path.join(keveDir, 'test-artifacts');
+    const latestLink = path.join(artifactsDir, 'latest');
+    try {
+        const target = fs.readlinkSync(latestLink);
+        return path.resolve(artifactsDir, target);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get branch-specific directory under .keve/
+ * Uses current git branch name to create/find .keve/{branch}/
+ */
+function getBranchDir(keveDir) {
+    if (!keveDir)
+        return null;
+    // Don't create branch dirs under keve_test_spec/ (legacy keveDir) — only under .keve/
+    if (!keveDir.endsWith(path.join('.keve')) && !keveDir.includes(`${path.sep}.keve${path.sep}`))
+        return null;
+    const branch = getCurrentBranch();
+    if (!branch)
+        return null;
+    const branchDir = path.join(keveDir, branch);
+    if (!fs.existsSync(branchDir)) {
+        fs.mkdirSync(branchDir, { recursive: true });
+    }
+    return branchDir;
+}
+/**
+ * Get current git branch name
+ */
+function getCurrentBranch() {
+    try {
+        return (0, child_process_1.execSync)('git branch --show-current', { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 获取 git 用户名
+ */
+function getGitUserName() {
+    try {
+        return (0, child_process_1.execSync)('git config user.name', { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        return process.env.KEVE_USER_NAME || '';
+    }
+}
+/**
+ * 获取 git remote origin 仓库名
+ */
+function getGitRepoName() {
+    try {
+        const url = (0, child_process_1.execSync)('git remote get-url origin', { encoding: 'utf-8' }).trim();
+        const parts = url.replace(/\.git$/, '').split('/');
+        return parts[parts.length - 1] || '';
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * 获取当前 git 分支名
+ */
+function getGitBranchName() {
+    try {
+        return (0, child_process_1.execSync)('git branch --show-current', { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+// ─── Run State (run-state.yaml) ─────────────────────────────────────────
+const RUN_STATE_FILENAME = 'run-state.yaml';
+/**
+ * Resolve task directory from KEVE_TASK_DIR env or keveDir + branch.
+ * Returns absolute path to the task root (e.g. .keve/mr-868-temp).
+ */
+function resolveTaskDir(keveDir) {
+    if (process.env.KEVE_TASK_DIR) {
+        return path.resolve(process.cwd(), process.env.KEVE_TASK_DIR);
+    }
+    // Auto-detect: find branch-specific task dir under .keve/{branch}/
+    if (keveDir) {
+        const branch = getCurrentBranch();
+        if (branch) {
+            const branchDir = path.join(keveDir, branch);
+            if (fs.existsSync(branchDir))
+                return branchDir;
+        }
+        // Fallback: keveDir itself if it has run-state.yaml
+        if (fs.existsSync(path.join(keveDir, RUN_STATE_FILENAME)))
+            return keveDir;
+    }
+    return null;
+}
+/**
+ * Read run-state.yaml from task directory.
+ * Returns default state if file doesn't exist.
+ */
+function readRunState(taskDir) {
+    const filePath = path.join(taskDir, RUN_STATE_FILENAME);
+    if (fs.existsSync(filePath)) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const parsed = yaml.parse(content);
+            return {
+                current_round: parsed.current_round || 0,
+                last_run_at: parsed.last_run_at,
+                rounds: parsed.rounds || {},
+            };
+        }
+        catch {
+            // Corrupted file — start fresh
+        }
+    }
+    return { current_round: 0, rounds: {} };
+}
+/**
+ * Write run-state.yaml to task directory.
+ */
+function writeRunState(taskDir, state) {
+    const filePath = path.join(taskDir, RUN_STATE_FILENAME);
+    fs.writeFileSync(filePath, yaml.stringify(state), 'utf-8');
+}
+/**
+ * Get next round number and update run-state.yaml.
+ */
+function getNextRoundFromState(taskDir) {
+    const state = readRunState(taskDir);
+    const next = state.current_round + 1;
+    state.current_round = next;
+    state.last_run_at = new Date().toISOString();
+    state.rounds[next] = {
+        status: 'running',
+        started_at: new Date().toISOString(),
+    };
+    writeRunState(taskDir, state);
+    return next;
+}
+/**
+ * Mark a round as completed with stats.
+ */
+function completeRound(taskDir, round, stats) {
+    const state = readRunState(taskDir);
+    if (state.rounds[round]) {
+        state.rounds[round].status = 'completed';
+        state.rounds[round].completed_at = new Date().toISOString();
+        state.rounds[round].passed = stats.passed;
+        state.rounds[round].failed = stats.failed;
+        state.rounds[round].skipped = stats.skipped;
+        writeRunState(taskDir, state);
+    }
+}

package/dist/core/action-log-writer.d.ts

@@ -0,0 +1,47 @@
+/**
+ * action-log-writer — Append action-log entries to action-log.jsonl
+ *
+ * Each line is a JSON object: { scene, step, action, source, result, timestamp }
+ * Used by script-refine agent to discover deterministic callbacks from Re-Act traces.
+ */
+export interface ActionLogRecord {
+    scene: string;
+    step: string;
+    stepOrder: number;
+    action: {
+        tool: string;
+        role?: string;
+        name?: string;
+        url?: string;
+        text?: string;
+        key?: string;
+        direction?: string;
+        time?: number;
+        submit?: boolean;
+        reason?: string;
+        success?: boolean;
+    };
+    source: 'deterministic' | 'react' | 'evaluate';
+    result: 'ok' | 'error' | 'achieved' | 'not_achieved';
+    error?: string;
+    evaluation?: string;
+    memory?: string;
+    nextGoal?: string;
+    gap?: string;
+    screenshotPath?: string;
+    snapshotPreview?: string;
+    fnSource?: string;
+    timestamp: string;
+}
+export declare class ActionLogWriter {
+    private filePath;
+    constructor(taskDir?: string);
+    /** Append a single record */
+    append(record: ActionLogRecord): void;
+    /** Append multiple records */
+    appendAll(records: ActionLogRecord[]): void;
+    /** Read all records (for script-refine) */
+    readAll(): ActionLogRecord[];
+    /** Get file path for external consumers */
+    getFilePath(): string;
+}

package/dist/{tools/write-file.js → core/action-log-writer.js}

@@ -1,4 +1,10 @@
 "use strict";
+/**
+ * action-log-writer — Append action-log entries to action-log.jsonl
+ *
+ * Each line is a JSON object: { scene, step, action, source, result, timestamp }
+ * Used by script-refine agent to discover deterministic callbacks from Re-Act traces.
+ */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -33,31 +39,41 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeFileTool = exports.WriteFileInputSchema = void 0;
-/**
- * write_file tool — write content to a file
- *
- * Reference: gemini-cli WriteFileTool
- */
-const fs = __importStar(require("node:fs/promises"));
+exports.ActionLogWriter = void 0;
+const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
-const v4_1 = require("zod/v4");
-exports.WriteFileInputSchema = v4_1.z.object({
-    path: v4_1.z.string().describe('File path (relative to cwd or absolute)'),
-    content: v4_1.z.string().describe('Content to write to the file'),
-    createDirs: v4_1.z.boolean().default(true).describe('Automatically create parent directories'),
-});
-exports.writeFileTool = {
-    name: 'write_file',
-    description: 'Write content to a file. Overwrites if exists, creates if not. Auto-creates parent directories.',
-    inputSchema: exports.WriteFileInputSchema,
-    execute: async (args, context) => {
-        const cwd = context?.cwd ?? process.cwd();
-        const filePath = path.isAbsolute(args.path) ? args.path : path.resolve(cwd, args.path);
-        if (args.createDirs) {
-            await fs.mkdir(path.dirname(filePath), { recursive: true });
+class ActionLogWriter {
+    filePath;
+    constructor(taskDir) {
+        const dir = taskDir || process.env.KEVE_TASK_DIR || '.keve';
+        const logDir = path.join(dir, 'test-artifacts', `round-${process.env.KEVE_ROUND || 'latest'}`);
+        fs.mkdirSync(logDir, { recursive: true });
+        this.filePath = path.join(logDir, 'action-log.jsonl');
+    }
+    /** Append a single record */
+    append(record) {
+        const line = JSON.stringify(record);
+        fs.appendFileSync(this.filePath, line + '\n', 'utf-8');
+    }
+    /** Append multiple records */
+    appendAll(records) {
+        for (const record of records) {
+            this.append(record);
         }
-        await fs.writeFile(filePath, args.content, 'utf-8');
-        return { ok: true, path: filePath, bytes: Buffer.byteLength(args.content, 'utf-8') };
-    },
-};
+    }
+    /** Read all records (for script-refine) */
+    readAll() {
+        if (!fs.existsSync(this.filePath))
+            return [];
+        const content = fs.readFileSync(this.filePath, 'utf-8');
+        return content
+            .split('\n')
+            .filter(line => line.trim())
+            .map(line => JSON.parse(line));
+    }
+    /** Get file path for external consumers */
+    getFilePath() {
+        return this.filePath;
+    }
+}
+exports.ActionLogWriter = ActionLogWriter;