@usecontextlayer/ctxe 0.4.1 → 0.4.2

package/dist/cli.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="b91f2a1b-d2ef-5d42-a3e9-b2e7ffe81cc4")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="d97c9b53-4423-5a49-9ffa-bd79394a4775")}catch(e){}}();
 import { createRequire } from "node:module";
 import * as Sentry from "@sentry/node";
 import * as xi from "node:fs";
@@ -59,7 +59,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
 //#region package.json
-var version$1 = "0.4.1";
+var version$1 = "0.4.2";
 
 //#endregion
 //#region sentry.ts
@@ -29490,7 +29490,7 @@ function validate(raw, sourcePath) {
 }
 function applyDefaults(input) {
 	return {
-		synthesizerImage: input.synthesizerImage ?? "ghcr.io/usecontextlayer/ctx-sandbox:0.4.1",
+		synthesizerImage: input.synthesizerImage ?? "ghcr.io/usecontextlayer/ctx-sandbox:0.4.2",
 		...input.microsandbox !== void 0 ? { microsandbox: input.microsandbox } : {},
 		...input.oldestConsideredPoint !== void 0 ? { oldestConsideredPoint: input.oldestConsideredPoint } : {},
 		maxSliceSize: input.maxSliceSize ?? 864e5,
@@ -29663,6 +29663,9 @@ async function commitSynthesizerTransaction(repo, input) {
 async function commitRootRepair(repo, input) {
 	return await createCommit(repo, buildRootRepairCommitMessage(input));
 }
+async function commitRootReset(repo, input) {
+	return await createCommit(repo, buildRootResetCommitMessage(input));
+}
 async function pushToOrigin(repo) {
 	if (repo.mode !== "remote") return;
 	await runGit(repo, [
@@ -29792,6 +29795,14 @@ function buildRootRepairCommitMessage(input) {
 		""
 	].join("\n");
 }
+function buildRootResetCommitMessage(input) {
+	return [
+		`ctxe: root reset @ ${input.resetId}`,
+		"",
+		"reset: wipe synthesized content + cursors",
+		""
+	].join("\n");
+}
 function parsePorcelainV1Z(stdout) {
 	const entries = stdout.split("\0").filter((entry) => entry.length > 0);
 	const paths = [];
@@ -30160,7 +30171,7 @@ engine has prepared three files in your working directory:
 - \`./output/\` — the only path that persists back to the host. Anything written
   elsewhere is lost when the sandbox exits.
 
-A \`contextengine\` skill is installed. Read and follow it — it defines how to
+A \`contextengine-synthesizer\` skill is installed. Read and follow it — it defines how to
 synthesize well. Then do the work in \`./synthesizer.md\` and exit.
 
 A clean exit is success; the engine records the run from its own metadata. Do
@@ -31335,6 +31346,53 @@ function formatCombinedRepairError(repo, branch, tree) {
 		"Operator must inspect and choose the order manually."
 	].join("\n");
 }
+const RESERVED_OUTPUT_SUBDIRS = new Set(["types", "views"]);
+const OUTPUT_DIR_RELATIVE = "output";
+const CURSORS_DIR_RELATIVE = ".engine/cursors";
+async function planRootReset(rootDir) {
+	const cursorFiles = (await readDirNames(cursorsDirPath(rootDir))).filter((name) => name.endsWith(".json"));
+	return {
+		contentPaths: (await readDirNames(path.join(rootDir, OUTPUT_DIR_RELATIVE))).filter((name) => !RESERVED_OUTPUT_SUBDIRS.has(name)).map((name) => path.join(OUTPUT_DIR_RELATIVE, name)).sort(),
+		cursorPaths: cursorFiles.map((name) => path.join(CURSORS_DIR_RELATIVE, name)).sort()
+	};
+}
+async function runRootReset(repo, options = {}) {
+	const preflight = await runRootPreflight(repo);
+	if (!preflight.ready && !options.force) throw new Error(formatNotReadyError(repo, preflight.issues));
+	const plan = await planRootReset(repo.rootDir);
+	for (const relativePath of [...plan.cursorPaths, ...plan.contentPaths]) await rm(path.join(repo.rootDir, relativePath), {
+		force: true,
+		recursive: true
+	});
+	if ((await inspectWorkingTree(repo)).clean) return { kind: "no_op" };
+	const { sha } = await commitRootReset(repo, { resetId: v7() });
+	await pushToOrigin(repo);
+	return {
+		commit: {
+			pushed: repo.mode === "remote",
+			sha
+		},
+		kind: "reset",
+		removedContent: plan.contentPaths,
+		removedCursors: plan.cursorPaths
+	};
+}
+async function readDirNames(dir) {
+	try {
+		return await readdir$1(dir);
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return [];
+		throw error;
+	}
+}
+function formatNotReadyError(repo, issues) {
+	const list = issues.map((issue) => `  - ${issue.message}`).join("\n");
+	return [
+		`RootReset refuses to act: engine root '${repo.rootDir}' is not ready.`,
+		list,
+		"Commit your authored config (or run 'ctxe repair'), or pass --force to reset anyway."
+	].join("\n");
+}
 const SOURCE_UPDATED_AT_COLUMN = "_ctx_source_updated_at";
 async function captureWatermark(input) {
 	const sql = src_default(input.databaseUrl);
@@ -31510,6 +31568,29 @@ async function runRepairCommand(repo) {
 	process.stdout.write(`${formatJsonOutput(result)}\n`);
 }
 
+//#endregion
+//#region commands/reset.ts
+async function runResetCommand(input) {
+	const { repo, yes, force } = input;
+	if (!yes) {
+		const preflight = await runRootPreflight(repo);
+		const plan = await planRootReset(repo.rootDir);
+		process.stdout.write(`${formatJsonOutput({
+			dryRun: true,
+			hint: "pass --yes to execute (commits the wipe), then 'ctxe backfill <name>' to rebuild",
+			issues: preflight.issues,
+			ready: preflight.ready,
+			wouldRemove: {
+				content: plan.contentPaths,
+				cursors: plan.cursorPaths
+			}
+		})}\n`);
+		return;
+	}
+	const result = await runRootReset(repo, { force });
+	process.stdout.write(`${formatJsonOutput(result)}\n`);
+}
+
 //#endregion
 //#region commands/run.ts
 async function runRunCommand(input) {
@@ -31612,6 +31693,13 @@ function createProgram() {
 	program.command("repair").description("Explicit out-of-band root repair: safe fast-forward when clean and stale, or dirty-root rollback that preserves .engine/runs/**. Refuses local-ahead state, divergence, and the combined stale-plus-dirty case.").action(async function() {
 		await runRepairCommand(resolveRepoContext(this));
 	});
+	program.command("reset").option("--yes", "Execute the reset (delete cursors + wipe synthesized content, then commit). Without it, prints the plan and exits without mutating.").option("--force", "Reset even when the root is not preflight-ready (e.g. a dirty working tree). Use with care; normally you commit authored config or run 'ctxe repair' first.").description("Reset the whole workspace to a clean pre-synthesis state so it can be rebuilt from scratch: delete every synthesizer cursor (the next run bootstraps from engine.json's oldestConsideredPoint) and wipe all synthesized content under output/ except the authored types/ and views/, in one commit. Whole-workspace by design — output/ is not partitioned by synthesizer. Preserves .engine/runs/**. Default is a dry run; pass --yes to execute, then rebuild with 'ctxe backfill <synthesizer>' or 'ctxe daemon start'.").action(async function(options) {
+		await runResetCommand({
+			force: options.force ?? false,
+			repo: resolveRepoContext(this),
+			yes: options.yes ?? false
+		});
+	});
 	program.command("run").argument("<synthesizer>", "Synthesizer name").option("--database-url <url>", "Postgres URL of the ContextBase database the synthesizer reads from. Falls back to CTXB_DATABASE_URL.").description("Run a single synthesizer once. Exits non-zero on a failed or timed-out run.").action(async function(synthesizerName, options) {
 		await runRunCommand({
 			databaseUrl: options.databaseUrl,
@@ -31655,4 +31743,4 @@ runCli().catch((error) => {
 //#endregion
 export { createProgram, resolveRepoContext, resolveRuntimePaths, runCli };
 //# sourceMappingURL=cli.mjs.map
-//# debugId=b91f2a1b-d2ef-5d42-a3e9-b2e7ffe81cc4
+//# debugId=d97c9b53-4423-5a49-9ffa-bd79394a4775