hadara 0.1.0-rc.0

package/dist/cli/run.js

@@ -0,0 +1,191 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRunCommand = handleRunCommand;
+exports.attachRunEvidence = attachRunEvidence;
+exports.readScriptedProviderSteps = readScriptedProviderSteps;
+exports.readFakeShellFixtures = readFakeShellFixtures;
+exports.parseRunMaxSteps = parseRunMaxSteps;
+const node_fs_1 = __importDefault(require("node:fs"));
+const workspace_1 = require("../core/workspace");
+const policy_1 = require("../policy/policy");
+const evidence_1 = require("../agent/evidence");
+const loop_1 = require("../agent/loop");
+const scripted_provider_1 = require("../providers/scripted-provider");
+const run_scaffold_1 = require("./run-scaffold");
+const args_1 = require("./args");
+async function handleRunCommand(input) {
+    const sub = input.args[1];
+    if (sub === 'scaffold') {
+        const report = (0, run_scaffold_1.scaffoldRunScenario)(input.projectRoot, {
+            taskId: (0, args_1.getRequiredStringOption)(input.args, '--task'),
+            command: (0, args_1.getRequiredStringOption)(input.args, '--command'),
+            stdout: (0, args_1.getStringOption)(input.args, '--stdout', 'scaffolded fake-shell output') ?? 'scaffolded fake-shell output',
+            stderr: (0, args_1.getStringOption)(input.args, '--stderr', '') ?? '',
+            exitCode: (0, args_1.getIntegerOption)(input.args, '--exit-code', { fallback: 0, min: 0, max: 255 }) ?? 0
+        });
+        if (input.jsonOutput) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log(`[HADARA] Run scenario scaffolded: ${report.scriptPath}`);
+            console.log(`[HADARA] Fake shell fixtures: ${report.fixturesPath}`);
+        }
+        return true;
+    }
+    const taskId = (0, args_1.getStringOption)(input.args, '--task');
+    const mode = (0, policy_1.parsePermissionMode)((0, args_1.getStringOption)(input.args, '--mode', 'assisted') ?? 'assisted');
+    const request = extractRunRequest(input.args) || (taskId ? `Run task ${taskId}` : 'Run HADARA deterministic harness task.');
+    let result;
+    try {
+        const scriptPath = (0, args_1.getRequiredStringOption)(input.args, '--script');
+        const maxSteps = parseRunMaxSteps(input.args);
+        const fixturesPath = (0, args_1.getStringOption)(input.args, '--fake-shell-fixtures');
+        const script = readScriptedProviderSteps(input.projectRoot, scriptPath);
+        const fakeShellFixtures = fixturesPath ? readFakeShellFixtures(input.projectRoot, fixturesPath) : {};
+        result = await (0, loop_1.runAgentLoop)({
+            taskId,
+            request,
+            provider: new scripted_provider_1.ScriptedProvider(script),
+            mode,
+            maxSteps,
+            fakeShellFixtures
+        });
+    }
+    catch (error) {
+        if (!input.jsonOutput)
+            throw error;
+        result = createRunErrorReport({ taskId, request, mode, error });
+    }
+    result = attachRunEvidence(input.projectRoot, result);
+    if (input.jsonOutput) {
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else if (result.ok) {
+        console.log(`[HADARA] Agent loop passed: ${result.finalResponse ?? ''}`);
+    }
+    else {
+        console.log('[HADARA] Agent loop failed.');
+        for (const issue of result.issues) {
+            console.log(`- ${issue.code}: ${issue.message}${issue.step ? ` (step ${issue.step})` : ''}`);
+        }
+    }
+    if (!result.ok)
+        process.exitCode = 6;
+    return true;
+}
+function attachRunEvidence(projectRoot, result) {
+    try {
+        const evidence = (0, evidence_1.attachAgentLoopEvidence)(projectRoot, result);
+        if (evidence.length === 0)
+            return result;
+        return {
+            ...result,
+            evidence: [...(result.evidence ?? []), ...evidence]
+        };
+    }
+    catch (error) {
+        return {
+            ...result,
+            ok: false,
+            issues: [
+                ...result.issues,
+                {
+                    severity: 'error',
+                    code: 'AGENT_LOOP_EVIDENCE_FAILED',
+                    message: error instanceof Error ? error.message : String(error)
+                }
+            ]
+        };
+    }
+}
+function extractRunRequest(args) {
+    const optionsWithValues = new Set(['--project', '--task', '--script', '--fake-shell-fixtures', '--mode', '--max-steps']);
+    const requestParts = [];
+    for (let index = 1; index < args.length; index += 1) {
+        const value = args[index];
+        if (value === '--json')
+            continue;
+        if (optionsWithValues.has(value)) {
+            index += 1;
+            continue;
+        }
+        if (value.startsWith('--'))
+            continue;
+        requestParts.push(value);
+    }
+    return requestParts.join(' ').trim();
+}
+function readScriptedProviderSteps(projectRoot, scriptPath) {
+    const parsed = readJsonFile(projectRoot, scriptPath);
+    if (!Array.isArray(parsed))
+        throw new Error('run --script must point to a JSON array');
+    return parsed.map((item, index) => {
+        if (!item || typeof item !== 'object') {
+            throw new Error(`run --script item ${index + 1} must be an object`);
+        }
+        const record = item;
+        if (typeof record.response !== 'string') {
+            throw new Error(`run --script item ${index + 1} requires a string response`);
+        }
+        return {
+            response: record.response,
+            ...(typeof record.match === 'string' ? { match: record.match } : {}),
+            ...(isScriptedFinishReason(record.finishReason) ? { finishReason: record.finishReason } : {})
+        };
+    });
+}
+function readFakeShellFixtures(projectRoot, fixturesPath) {
+    const parsed = readJsonFile(projectRoot, fixturesPath);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('run --fake-shell-fixtures must point to a JSON object');
+    }
+    const fixtures = {};
+    for (const [command, value] of Object.entries(parsed)) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            throw new Error(`fake shell fixture for ${command} must be an object`);
+        }
+        const record = value;
+        if (typeof record.exitCode !== 'number') {
+            throw new Error(`fake shell fixture for ${command} requires numeric exitCode`);
+        }
+        fixtures[command] = {
+            exitCode: record.exitCode,
+            ...(typeof record.stdout === 'string' ? { stdout: record.stdout } : {}),
+            ...(typeof record.stderr === 'string' ? { stderr: record.stderr } : {})
+        };
+    }
+    return fixtures;
+}
+function readJsonFile(projectRoot, filePath) {
+    const resolvedFile = (0, workspace_1.resolveProjectFile)(projectRoot, filePath);
+    return JSON.parse(node_fs_1.default.readFileSync(resolvedFile.absolutePath, 'utf8'));
+}
+function parseRunMaxSteps(args) {
+    return (0, args_1.getIntegerOption)(args, '--max-steps', { fallback: 6, min: 1, max: 32 }) ?? 6;
+}
+function createRunErrorReport(input) {
+    const code = input.error instanceof workspace_1.WorkspaceFileError ? input.error.code : 'RUN_INPUT_INVALID';
+    const message = input.error instanceof Error ? input.error.message : String(input.error);
+    return {
+        schemaVersion: 'hadara.agent.loop.v1',
+        command: 'agent.loop',
+        ok: false,
+        ...(input.taskId ? { taskId: input.taskId } : {}),
+        mode: input.mode,
+        request: input.request,
+        steps: [],
+        issues: [
+            {
+                severity: 'error',
+                code,
+                message
+            }
+        ]
+    };
+}
+function isScriptedFinishReason(value) {
+    return value === 'stop' || value === 'length' || value === 'tool_call' || value === 'error';
+}

package/dist/cli/smoke.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSmokeCommand = handleSmokeCommand;
+const clean_checkout_smoke_1 = require("../services/clean-checkout-smoke");
+const feature_smoke_1 = require("../services/feature-smoke");
+const args_1 = require("./args");
+function handleSmokeCommand(input) {
+    if (input.args[0] !== 'smoke')
+        return false;
+    if (input.args[1] === 'clean-checkout') {
+        const report = (0, clean_checkout_smoke_1.createCleanCheckoutSmokeReport)({
+            paths: input.paths,
+            execute: (0, args_1.getFlag)(input.args, '--execute'),
+            workspace: (0, args_1.getStringOption)(input.args, '--workspace'),
+            keepTemp: (0, args_1.getFlag)(input.args, '--keep-temp'),
+            taskId: (0, args_1.getStringOption)(input.args, '--task'),
+            attachEvidence: (0, args_1.getFlag)(input.args, '--attach-evidence'),
+            noEvidence: (0, args_1.getFlag)(input.args, '--no-evidence'),
+            timeoutSeconds: (0, args_1.getIntegerOption)(input.args, '--timeout', { min: 1 })
+        });
+        if (input.jsonOutput) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log(`${report.ok ? 'passed' : 'failed'} | smoke clean-checkout | ${report.mode}`);
+            for (const step of report.steps) {
+                console.log(`${step.status} | ${step.command} | ${step.summary}`);
+            }
+            for (const issue of report.issues) {
+                console.log(`${issue.severity} | ${issue.code} | ${issue.message}`);
+            }
+        }
+        if (!report.ok)
+            process.exitCode = 6;
+        return true;
+    }
+    if (input.args[1] !== 'run')
+        return false;
+    const report = (0, feature_smoke_1.createFeatureSmokeReport)({
+        profile: (0, args_1.getStringOption)(input.args, '--profile', 'core'),
+        paths: input.paths
+    });
+    if (input.jsonOutput) {
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        console.log(`${report.ok ? 'passed' : 'failed'} | smoke run | profile ${report.profile}`);
+        for (const step of report.steps) {
+            console.log(`${step.status} | ${step.command} | ${step.summary}`);
+        }
+        for (const issue of report.issues) {
+            console.log(`${issue.severity} | ${issue.code} | ${issue.message}`);
+        }
+    }
+    if (!report.ok)
+        process.exitCode = 6;
+    return true;
+}

package/dist/cli/status-json.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatOpsStatusReport = exports.createOpsStatusReport = void 0;
+var operations_status_service_1 = require("../services/operations-status-service");
+Object.defineProperty(exports, "createOpsStatusReport", { enumerable: true, get: function () { return operations_status_service_1.createOpsStatusReport; } });
+Object.defineProperty(exports, "formatOpsStatusReport", { enumerable: true, get: function () { return operations_status_service_1.formatOpsStatusReport; } });

package/dist/cli/status.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleStatusCommand = handleStatusCommand;
+exports.handleOpsCommand = handleOpsCommand;
+const operations_status_service_1 = require("../services/operations-status-service");
+function handleStatusCommand(input) {
+    if (input.args[0] !== 'status')
+        return false;
+    printStatus(input.projectRoot, input.jsonOutput);
+    return true;
+}
+function handleOpsCommand(input) {
+    if (input.args[0] !== 'ops' || input.args[1] !== 'status')
+        return false;
+    printStatus(input.projectRoot, input.jsonOutput);
+    return true;
+}
+function printStatus(projectRoot, jsonOutput) {
+    const report = (0, operations_status_service_1.createOpsStatusReport)(projectRoot);
+    if (jsonOutput) {
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        console.log((0, operations_status_service_1.formatOpsStatusReport)(report));
+    }
+}

package/dist/cli/task-json.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTaskListReport = exports.createTaskShowReport = exports.createTaskReadReport = exports.createTaskListReport = void 0;
+var task_read_model_1 = require("../services/task-read-model");
+Object.defineProperty(exports, "createTaskListReport", { enumerable: true, get: function () { return task_read_model_1.createTaskListReport; } });
+Object.defineProperty(exports, "createTaskReadReport", { enumerable: true, get: function () { return task_read_model_1.createTaskReadReport; } });
+Object.defineProperty(exports, "createTaskShowReport", { enumerable: true, get: function () { return task_read_model_1.createTaskShowReport; } });
+Object.defineProperty(exports, "formatTaskListReport", { enumerable: true, get: function () { return task_read_model_1.formatTaskListReport; } });

package/dist/cli/task.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleTaskCommand = handleTaskCommand;
+exports.extractTaskCreateTitle = extractTaskCreateTitle;
+const task_capsule_1 = require("../task/task-capsule");
+const task_json_1 = require("./task-json");
+function handleTaskCommand(input) {
+    const sub = input.args[1];
+    if (sub === 'create') {
+        const title = extractTaskCreateTitle(input.args);
+        if (!title)
+            throw new Error('task create requires a title');
+        const task = (0, task_capsule_1.createTaskCapsule)(input.projectRoot, title);
+        console.log(`[HADARA] Created ${task.id}: ${task.title}`);
+        console.log(task.dir);
+        return true;
+    }
+    if (sub === 'list') {
+        const report = (0, task_json_1.createTaskListReport)(input.projectRoot);
+        if (input.jsonOutput) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else {
+            console.log((0, task_json_1.formatTaskListReport)(report));
+        }
+        return true;
+    }
+    if (sub === 'show') {
+        const id = input.args[2];
+        if (!id)
+            throw new Error('task show requires <task-id>');
+        const report = (0, task_json_1.createTaskShowReport)(input.projectRoot, id);
+        if (input.jsonOutput) {
+            console.log(JSON.stringify(report, null, 2));
+        }
+        else if (report.ok && report.task) {
+            console.log(report.task.taskMarkdown);
+        }
+        else {
+            console.log(`[HADARA] Task not found: ${id}`);
+        }
+        if (!report.ok)
+            process.exitCode = 6;
+        return true;
+    }
+    return false;
+}
+function extractTaskCreateTitle(args) {
+    const optionsWithValues = new Set(['--project']);
+    const titleParts = [];
+    for (let index = 2; index < args.length; index += 1) {
+        const value = args[index];
+        if (value === '--json')
+            continue;
+        if (optionsWithValues.has(value)) {
+            index += 1;
+            continue;
+        }
+        if (value.startsWith('--'))
+            continue;
+        titleParts.push(value);
+    }
+    return titleParts.join(' ').trim();
+}

package/dist/cli/tools.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleToolsCommand = handleToolsCommand;
+const tools_list_1 = require("../services/tools-list");
+function handleToolsCommand(input) {
+    const sub = input.args[1];
+    if (sub !== 'list')
+        return false;
+    const report = (0, tools_list_1.createToolsListReport)();
+    if (input.jsonOutput) {
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        for (const surface of report.surfaces.cli) {
+            console.log(`cli | ${surface.category} | ${surface.readOnly ? 'read-only' : 'writes-or-executes'} | ${surface.name}`);
+        }
+        for (const surface of report.surfaces.mcp) {
+            console.log(`mcp | ${surface.category} | ${surface.readOnly ? 'read-only' : 'writes'} | ${surface.name}`);
+        }
+        for (const disabled of report.disabled) {
+            console.log(`disabled | ${disabled.category} | ${disabled.name} | ${disabled.reason}`);
+        }
+    }
+    return true;
+}

package/dist/cli/tui.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleTuiCommand = handleTuiCommand;
+const args_1 = require("./args");
+const read_model_1 = require("../tui/read-model");
+const snapshot_1 = require("../tui/snapshot");
+const terminal_1 = require("../tui/terminal");
+const theme_1 = require("../tui/theme");
+function handleTuiCommand(input) {
+    if (input.args[0] !== 'tui')
+        return false;
+    const sub = input.args[1];
+    if (sub && sub !== '--snapshot' && sub !== '--compact' && sub !== '--json' && sub !== '--cache' && sub !== '--no-cache' && !sub.startsWith('--'))
+        return false;
+    const widthPolicy = (0, args_1.getFlag)(input.args, '--compact') ? 'compact' : undefined;
+    const width = (0, args_1.getIntegerOption)(input.args, '--width', { min: 20, max: 300 });
+    const height = (0, args_1.getIntegerOption)(input.args, '--height', { min: 10, max: 120 });
+    const cacheEnabled = (0, args_1.getFlag)(input.args, '--cache') && !(0, args_1.getFlag)(input.args, '--no-cache');
+    const theme = (0, args_1.getFlag)(input.args, '--no-color') ? 'none' : (0, theme_1.normalizeTuiThemeName)((0, args_1.getStringOption)(input.args, '--theme'), 'hadara');
+    const output = input.output ?? process.stdout;
+    const terminalInput = input.input ?? process.stdin;
+    if ((0, args_1.getFlag)(input.args, '--snapshot')) {
+        const snapshot = (0, snapshot_1.renderTuiSnapshot)((0, read_model_1.createTuiReadModel)(input.projectRoot), { width, height, widthPolicy, theme: (0, args_1.getFlag)(input.args, '--color') ? theme : 'none' });
+        if (input.jsonOutput) {
+            output.write(`${JSON.stringify({ schemaVersion: 'hadara.tui.snapshot.cli.v1', command: 'tui.snapshot', ok: true, text: snapshot.text }, null, 2)}\n`);
+        }
+        else {
+            output.write(snapshot.text);
+        }
+        return true;
+    }
+    if (!terminalInput.isTTY) {
+        if (input.jsonOutput) {
+            output.write(`${JSON.stringify(createTuiCliError('TUI_REQUIRES_TTY', 'TUI requires an interactive terminal. Use hadara tui --snapshot.'), null, 2)}\n`);
+        }
+        else {
+            output.write('[HADARA] TUI requires an interactive terminal. Use hadara tui --snapshot for a read-only smoke render.\n');
+        }
+        process.exitCode = 1;
+        return true;
+    }
+    let cleanup = () => undefined;
+    const session = (0, terminal_1.createTuiTerminalSession)({
+        projectRoot: input.projectRoot,
+        input: terminalInput,
+        output,
+        width,
+        height,
+        widthPolicy,
+        theme,
+        cache: { enabled: cacheEnabled },
+        asyncLoading: input.input ? false : true,
+        onStop: () => cleanup()
+    });
+    cleanup = () => {
+        process.off('SIGINT', cleanup);
+        process.off('exit', cleanup);
+        session.stop();
+    };
+    process.once('SIGINT', cleanup);
+    process.once('exit', cleanup);
+    session.start();
+    return true;
+}
+function createTuiCliError(code, message) {
+    return {
+        schemaVersion: 'hadara.tui.cli.error.v1',
+        command: 'tui',
+        ok: false,
+        issues: [{ severity: 'error', code, message }]
+    };
+}

package/dist/cli/write-preflight.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleWriteCommand = handleWriteCommand;
+const write_preflight_1 = require("../services/write-preflight");
+function handleWriteCommand(input) {
+    if (input.args[0] !== 'write')
+        return false;
+    const sub = input.args[1];
+    if (sub !== 'preflight')
+        return false;
+    const report = (0, write_preflight_1.createWritePreflightReport)(input.projectRoot, input.args.slice(2));
+    if (input.jsonOutput) {
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        console.log(`[HADARA] Write preflight for ${report.command}: ${report.ok ? 'ok' : 'not ok'}`);
+        for (const writePath of report.writes) {
+            console.log(`- ${writePath}`);
+        }
+        for (const issue of report.issues) {
+            console.log(`[${issue.severity}] ${issue.code}: ${issue.message}`);
+        }
+    }
+    if (!report.ok)
+        process.exitCode = 6;
+    return true;
+}

package/dist/core/audit.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeAuditEvent = writeAuditEvent;
+const node_path_1 = __importDefault(require("node:path"));
+const fs_1 = require("./fs");
+const redaction_1 = require("./redaction");
+const events_1 = require("./events");
+function writeAuditEvent(auditDir, event) {
+    (0, fs_1.ensureDir)(auditDir);
+    const day = new Date().toISOString().slice(0, 10);
+    const filePath = node_path_1.default.join(auditDir, `${day}.jsonl`);
+    const time = new Date().toISOString();
+    const structuredEvent = (0, events_1.createHadaraEvent)({
+        time,
+        level: auditRiskToEventLevel(event.risk),
+        actor: event.actor,
+        eventType: event.event_type,
+        taskId: event.task_id,
+        summary: event.summary,
+        payload: event.payload
+    });
+    const sanitized = {
+        time,
+        ...event,
+        summary: (0, redaction_1.redactSecrets)(event.summary),
+        payload: structuredEvent.payload,
+        event: structuredEvent
+    };
+    (0, fs_1.writeJsonl)(filePath, sanitized);
+    return filePath;
+}
+function auditRiskToEventLevel(risk) {
+    if (risk === 'blocked')
+        return 'error';
+    if (risk === 'high')
+        return 'warn';
+    return 'info';
+}

package/dist/core/events.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HadaraEventSchemaError = void 0;
+exports.createHadaraEvent = createHadaraEvent;
+exports.assertHadaraEventSchema = assertHadaraEventSchema;
+exports.serializeHadaraEvent = serializeHadaraEvent;
+exports.sanitizePayload = sanitizePayload;
+const redaction_1 = require("./redaction");
+const schema_1 = require("./schema");
+class HadaraEventSchemaError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'HadaraEventSchemaError';
+    }
+}
+exports.HadaraEventSchemaError = HadaraEventSchemaError;
+function createHadaraEvent(input, options = {}) {
+    const event = {
+        schemaVersion: 'hadara.event.v1',
+        time: input.time ?? new Date().toISOString(),
+        level: input.level ?? 'info',
+        eventType: input.eventType,
+        actor: input.actor,
+        summary: (0, redaction_1.redactSecrets)(input.summary)
+    };
+    if (input.taskId)
+        event.taskId = input.taskId;
+    const payload = sanitizePayload(input.payload);
+    if (payload !== undefined)
+        event.payload = payload;
+    return options.assertSchema ? assertHadaraEventSchema(event) : event;
+}
+function assertHadaraEventSchema(event) {
+    const result = (0, schema_1.validateSchema)('hadara.event.v1', event);
+    if (!result.ok) {
+        const firstIssue = result.issues[0];
+        throw new HadaraEventSchemaError(firstIssue
+            ? `HADARA event failed schema validation: ${firstIssue.path} ${firstIssue.code} ${firstIssue.message}`
+            : 'HADARA event failed schema validation.');
+    }
+    return event;
+}
+function serializeHadaraEvent(event) {
+    return JSON.stringify(event);
+}
+function sanitizePayload(value) {
+    if (value === undefined)
+        return undefined;
+    const seen = new WeakSet();
+    const serialized = JSON.stringify(value, (_key, current) => {
+        if (typeof current === 'bigint')
+            return current.toString();
+        if (typeof current !== 'object' || current === null)
+            return current;
+        if (seen.has(current))
+            return '[Circular]';
+        seen.add(current);
+        return current;
+    });
+    if (serialized === undefined)
+        return undefined;
+    return JSON.parse((0, redaction_1.redactSecrets)(serialized));
+}

package/dist/core/fs.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDir = ensureDir;
+exports.writeFileIfMissing = writeFileIfMissing;
+exports.appendLine = appendLine;
+exports.readTextIfExists = readTextIfExists;
+exports.writeJsonl = writeJsonl;
+exports.slugify = slugify;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function ensureDir(dir) {
+    node_fs_1.default.mkdirSync(dir, { recursive: true });
+}
+function writeFileIfMissing(filePath, content) {
+    ensureDir(node_path_1.default.dirname(filePath));
+    if (node_fs_1.default.existsSync(filePath))
+        return false;
+    node_fs_1.default.writeFileSync(filePath, content, 'utf8');
+    return true;
+}
+function appendLine(filePath, line) {
+    ensureDir(node_path_1.default.dirname(filePath));
+    node_fs_1.default.appendFileSync(filePath, `${line}\n`, 'utf8');
+}
+function readTextIfExists(filePath) {
+    if (!node_fs_1.default.existsSync(filePath))
+        return null;
+    return node_fs_1.default.readFileSync(filePath, 'utf8');
+}
+function writeJsonl(filePath, event) {
+    appendLine(filePath, JSON.stringify(event));
+}
+function slugify(input) {
+    return input
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9가-힣]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 64) || 'task';
+}