@krapht/ork 1.0.0-alpha.2 → 1.0.0-alpha.20

package/dist/clean-DaHjs__2.mjs

@@ -1,88 +0,0 @@
-import { A as gitOk, O as removeWorktree } from "./src-Dujmvv4s.mjs";
-// ../core/src/worktree/clean.ts
-/**
-* @file What `ork worktrees clean` and `ork worktrees remove` do with what
-*   list.ts reads: the plan (what goes, what's kept and why), by one rule for
-*   every caller, and carrying it out. The CLI and the Worktrees panel both
-*   plan here, so neither removes what the other would keep.
-*/
-/** What names an item for `remove`: its branch, or its worktree's path. */
-const keyOf = (item) => item.branch ?? item.path ?? `${item.runId}/${item.nodeId}`;
-/** The reasons no `force` overrides: removing would break something. */
-const MAIN_CHECKOUT = "checked out in the main checkout";
-const RUN_GOING = "its run is still going";
-const kept = (item, skip) => ({
-	item,
-	removeWorktree: false,
-	deleteBranch: false,
-	skip
-});
-/** What clean does with one item. */
-const cleanStep = (item, options) => {
-	if (item.inMainCheckout) return kept(item, MAIN_CHECKOUT);
-	if (item.heldBy !== void 0) return kept(item, `checked out in ${item.heldBy}`);
-	if (options.live?.has(item.runId) === true) return kept(item, RUN_GOING);
-	if (item.dirty && !options.force) return kept(item, "uncommitted changes");
-	if (item.branch === void 0 && item.checkedOut === void 0 && item.ahead > 0 && !options.force) return kept(item, "commits on no branch");
-	const removable = item.path !== null && !item.missing;
-	if (options.branches && item.branch !== void 0 && !item.merged && !options.force) return {
-		item,
-		removeWorktree: removable,
-		deleteBranch: false,
-		skip: "branch not merged"
-	};
-	return {
-		item,
-		removeWorktree: removable,
-		deleteBranch: options.branches && item.branch !== void 0
-	};
-};
-/** Whether a step drops a worktree whose folder is gone, by its own path. */
-const stepPrunes = (step) => step.item.missing && step.item.path !== null && step.skip === void 0;
-/** Whether a step does anything. */
-const stepActs = (step) => step.removeWorktree || step.deleteBranch || stepPrunes(step);
-/**
-* What `ork worktrees clean` would do. A worktree with uncommitted changes, an
-* unmerged branch, or a detached worktree holding commits no branch has, is
-* kept unless `force`; one checked out in the main checkout or in a worktree
-* Ork didn't create, or whose run is still going, is kept even then.
-*/
-const planClean = (items, filter, options) => items.filter((item) => filter.runId === void 0 || item.runId === filter.runId).filter((item) => filter.key === void 0 || keyOf(item) === filter.key).filter((item) => !filter.merged || item.merged).map((item) => cleanStep(item, options));
-/**
-* Carries out one step; what it did goes into `done` as it goes. It touches
-* only its own item: a missing worktree is dropped by its own path (`git
-* worktree remove`), never by `git worktree prune`, which would drop every
-* missing worktree in the repository, the user's own included.
-*/
-const applyStep = async (root, step, force, done) => {
-	const { item } = step;
-	if (stepPrunes(step) && !step.removeWorktree && item.path !== null) {
-		await gitOk(root, [
-			"worktree",
-			"remove",
-			item.path
-		]);
-		done.push(`pruned ${item.path}`);
-	}
-	if (step.removeWorktree && item.path !== null) {
-		await removeWorktree(root, item.path, force);
-		done.push(`removed ${item.path}`);
-	}
-	if (step.deleteBranch && item.branch !== void 0) {
-		await gitOk(root, [
-			"branch",
-			force ? "-D" : "-d",
-			item.branch
-		]);
-		done.push(`deleted ${item.branch}`);
-	}
-};
-/**
-* Carries out a clean plan, step by step. What it did goes into `done` as it
-* goes, so a caller still has it when git fails halfway.
-*/
-const applyClean = async (root, steps, force, done = []) => {
-	for (const step of steps) await applyStep(root, step, force, done);
-	return done;
-};
-export { planClean as a, keyOf as i, applyStep as n, stepActs as o, cleanStep as r, stepPrunes as s, applyClean as t };

package/dist/context-DT8MfEIR.mjs

@@ -1,274 +0,0 @@
-import { C as workflowTextHash, Ct as walkChecks, On as LESSON_CAP_TOKENS, S as readProjectTriggers, St as checkWorkflowText, Tn as workflowDirOf, bn as placeFiles, lt as explainSession, wt as walkSummary, xn as placeFor } from "./src-Dujmvv4s.mjs";
-import { a as write, i as style, r as plain } from "./output-BLQWD6MJ.mjs";
-import { c as registeredProjects, i as refusedBuiltin, o as workflowArg, r as findWorkflowFiles, s as projectAt } from "./workflows-D1_WVukk.mjs";
-import path from "node:path";
-import { readFileSync } from "node:fs";
-import { defineCommand } from "citty";
-// src/commands/walk-report.ts
-/**
-* @file How `ork validate` shows a walk (RFC-009): one line on what it tried,
-*   and with `--paths`, each way a run can end. A gate's answer that ends the
-*   run shows here as an ending, not as a problem.
-*/
-const walkLine = (walk) => walk === void 0 ? [] : [style("dim", walkSummary(walk))];
-const endingLine = ({ status, notRun, paths }) => {
-	const ways = `${String(paths)} ${paths === 1 ? "way" : "ways"}`;
-	const word = status === "succeeded" ? style("green", status) : style("red", status);
-	const rest = notRun.length === 0 ? "every node ran" : `didn't run: ${notRun.map((id) => plain(id)).join(", ")}`;
-	return `  ${word} ${style("dim", `(${ways})`)} ${rest}`;
-};
-const endingLines = (ending) => [endingLine(ending), ...ending.choices.map((choice) => style("dim", `      ${plain(choice)}`))];
-/** Each ending, the ones that succeeded first, with one way to get there. */
-const pathLines = (walk) => {
-	const endings = walk?.endings ?? [];
-	return [...endings.filter(({ status }) => status === "succeeded"), ...endings.filter(({ status }) => status !== "succeeded")].flatMap((ending) => endingLines(ending));
-};
-// src/commands/validate.ts
-/**
-* @file `ork validate`: loads, parses and compiles workflow files with the
-*   project's rules (`.ork/project.yaml`) and the agents they name, checks
-*   their skill and context references, and reports diagnostics compiler-style,
-*   with file, line and column. `loadWorkflow` is shared with `ork run`.
-*/
-const hasErrors = (diagnostics) => diagnostics.some((d) => d.severity === "error");
-/**
-* Parses and compiles one workflow file, with the agents the user and its
-* project offer. `home` is the user's `~` (tests pass a folder); `registered`
-* the projects a caller's store has, else those of the store in `home`.
-*/
-const loadWorkflow = (file, cwd, home, registered = registeredProjects(home)) => {
-	const absolute = path.resolve(cwd, file);
-	const place = placeFor(path.dirname(absolute), registered);
-	const where = {
-		place,
-		workflowDir: workflowDirOf(place, absolute)
-	};
-	let text;
-	try {
-		text = readFileSync(path.resolve(cwd, file), "utf8");
-	} catch (error) {
-		return {
-			report: {
-				file,
-				diagnostics: [{
-					severity: "error",
-					code: "file.read",
-					message: error instanceof Error && "code" in error && error.code === "ENOENT" ? "file not found" : "cannot read file",
-					path: []
-				}]
-			},
-			workflow: null,
-			graph: null,
-			...where
-		};
-	}
-	const { diagnostics, workflow, graph, summary, locate } = checkWorkflowText(text, {
-		...where,
-		registered,
-		home
-	});
-	return {
-		report: {
-			file,
-			diagnostics,
-			...summary === void 0 ? {} : { summary }
-		},
-		workflow,
-		graph,
-		textHash: workflowTextHash(text),
-		...locate === void 0 ? {} : { locate },
-		...where
-	};
-};
-const validateFile = (file, cwd) => loadWorkflow(file, cwd).report;
-/**
-* Walks what loaded, with its findings on its report. `ork validate` and `ork
-* run` do this; the rest of what loads a workflow doesn't pay for a walk.
-*/
-const walkLoaded = async (loaded) => {
-	const { diagnostics, walk } = await walkChecks({
-		diagnostics: loaded.report.diagnostics,
-		graph: loaded.graph,
-		...loaded.locate === void 0 ? {} : { locate: loaded.locate }
-	});
-	return {
-		...loaded,
-		report: {
-			...loaded.report,
-			diagnostics,
-			...walk === void 0 ? {} : { walk }
-		}
-	};
-};
-const plural = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
-const diagnosticLine = (file, d) => {
-	const where = d.line === void 0 ? file : `${file}:${d.line}:${d.column ?? 1}`;
-	const severity = d.severity === "error" ? style(["red", "bold"], "error") : style(["yellow", "bold"], "warning");
-	return `${style("dim", where)} ${severity} ${d.message} ${style("dim", `(${d.code})`)}`;
-};
-/** The warnings alone, for a run that goes ahead despite them. */
-const warningLines = (report) => report.diagnostics.filter((d) => d.severity === "warning").map((d) => diagnosticLine(report.file, d));
-/** Human-readable report, one line per diagnostic, compiler style. */
-const formatReport = (report) => {
-	const lines = report.diagnostics.map((d) => diagnosticLine(report.file, d));
-	const errors = report.diagnostics.filter((d) => d.severity === "error").length;
-	const warnings = report.diagnostics.length - errors;
-	if (report.summary === void 0 && errors === 0) lines.push(`${style("green", "✓")} ${report.file}${warnings === 0 ? "" : style("dim", ` (${plural(warnings, "warning")})`)}`);
-	else if (report.summary !== void 0 && errors === 0) {
-		const { nodes, edges, entries } = report.summary;
-		const extra = warnings > 0 ? `, ${plural(warnings, "warning")}` : "";
-		lines.push(`${style("green", "✓")} ${report.file} ${style("dim", `(${plural(nodes, "node")}, ${plural(edges, "edge")}, starts at ${entries.join(", ")}${extra})`)}`);
-	} else lines.push(`${style("red", "✗")} ${report.file} ${style("dim", `(${plural(errors, "error")}, ${plural(warnings, "warning")})`)}`);
-	return [...lines, ...walkLine(report.walk)];
-};
-const validate = defineCommand({
-	meta: {
-		name: "validate",
-		description: "Check workflow files: schema, ownership tree, edges, loops and references, and walk every way through them"
-	},
-	args: {
-		files: {
-			type: "positional",
-			description: "Workflow files or names in .ork/workflows/ (default: every workflow there, and the project's triggers)",
-			required: false
-		},
-		json: {
-			type: "boolean",
-			description: "Print the reports as JSON",
-			default: false
-		},
-		paths: {
-			type: "boolean",
-			description: "List each way a run can end, and the choices that lead there",
-			default: false
-		}
-	},
-	run: async ({ args }) => {
-		const cwd = process.cwd();
-		if (refusedBuiltin(args._, cwd)) return;
-		const files = findWorkflowFiles(args._, cwd, placeFiles(projectAt(cwd)).workflows);
-		if (files.length === 0) {
-			write("No workflow files found. Run `ork init`, or pass a path.");
-			process.exitCode = 1;
-			return;
-		}
-		const place = projectAt(cwd);
-		const triggers = args._.length === 0 ? readProjectTriggers(place, void 0, registeredProjects()) : void 0;
-		const walked = [];
-		for (const file of files) {
-			const { report } = await walkLoaded(loadWorkflow(file, cwd));
-			walked.push(report);
-		}
-		const reports = [...walked, ...triggers?.present === true ? [{
-			file: path.relative(cwd, triggers.file),
-			diagnostics: [...triggers.diagnostics, ...triggers.triggers.flatMap((item) => item.diagnostics)]
-		}] : []];
-		if (args.json) write(JSON.stringify(reports, void 0, 2));
-		else for (const report of reports) {
-			for (const line of formatReport(report)) write(line);
-			if (args.paths) for (const line of pathLines(report.walk)) write(line);
-		}
-		if (reports.some((r) => hasErrors(r.diagnostics))) process.exitCode = 1;
-	}
-});
-// src/commands/context.ts
-/**
-* @file `ork context explain <wf> <node>`: what one node's session would load,
-*   layer by layer, as core's `explainSession` plans it without writing
-*   anything (one of Ork's own `ork:` workflows is written into the project's
-*   run folder first, as `ork run` does): its project instructions, every skill
-*   with the layer it came from and whether it is live, shadowed or switched
-*   off, its context files, its practices, and estimated tokens.
-*/
-/** Loads a workflow file and plans one node's session in it, in place. */
-const explainNode = (file, nodeId, cwd, home) => {
-	const { report, workflow, graph, place, workflowDir } = loadWorkflow(file, cwd, home);
-	if (workflow === null) return {
-		ok: false,
-		lines: formatReport(report)
-	};
-	const result = explainSession(workflow, graph, nodeId, {
-		root: place.root,
-		orkDir: place.dir,
-		workflowDir,
-		...home === void 0 ? {} : { home }
-	});
-	return result.ok ? result : {
-		ok: false,
-		lines: [result.error]
-	};
-};
-const approx = (count) => style("dim", `≈${count.toLocaleString("en")} tokens`);
-const formatExplanation = (e) => {
-	const width = Math.max(8, ...e.skills.map((s) => s.name.length));
-	const sourceWidth = Math.max(0, ...e.skills.map((s) => s.source.length));
-	const lines = [
-		`${style("bold", e.node)} ${style("dim", `(${e.type}) in ${e.workflow}`)}${e.template === void 0 ? "" : style("dim", `, planned as ${e.template}, the node it was spawned from`)}`,
-		"",
-		...e.agent === void 0 ? [] : [`${style("bold", "Agent")}  ${e.agent.name} ${style("dim", `(${e.agent.where})`)}  ${approx(e.agent.tokens)}`],
-		`${style("bold", "Instructions")}  ${e.instructions}`,
-		"",
-		style("bold", "Skills")
-	];
-	if (e.skills.length === 0) lines.push(style("dim", "  none"));
-	for (const s of e.skills) {
-		const mark = s.state === "live" ? style("green", "✓") : style("dim", "−");
-		const state = s.why === void 0 ? approx(s.tokens).replace("tokens", "tokens when used") : style("yellow", `off: ${s.why}`);
-		lines.push(`  ${mark} ${s.name.padEnd(width)}  ${s.layer.padEnd(8)}  ${style("dim", s.source.padEnd(sourceWidth))}  ${state}`);
-	}
-	lines.push("", style("bold", "Context files"));
-	if (e.files.length === 0) lines.push(style("dim", "  none"));
-	for (const f of e.files) {
-		const cut = f.cutFrom === void 0 ? "" : `  ${style("yellow", `cut at the ${LESSON_CAP_TOKENS.toLocaleString("en")}-token cap; the whole file is ${approx(f.cutFrom)}`)}`;
-		lines.push(`  ${f.layer.padEnd(8)}  ${f.name}  ${approx(f.tokens)}${cut}`);
-	}
-	lines.push("", style("bold", "Practices"));
-	for (const p of e.practices) lines.push(`  ${p.name.padEnd(8)}  ${approx(p.tokens)}`);
-	for (const name of e.skippedPractices) lines.push(`  ${name.padEnd(8)}  ${style("dim", "the project's own skill wins")}`);
-	if (e.practices.length === 0 && e.skippedPractices.length === 0) lines.push(style("dim", "  off"));
-	lines.push("", `Appended to Claude Code's system prompt: ${approx(e.appendedTokens)}`);
-	return lines;
-};
-const explain = defineCommand({
-	meta: {
-		name: "explain",
-		description: "Show what one node's session loads, layer by layer"
-	},
-	args: {
-		workflow: {
-			type: "positional",
-			description: "A workflow file, the name of one in the project's workflows (.ork/workflows/), or one of Ork's own (ork:feedback-apply)",
-			required: true
-		},
-		node: {
-			type: "positional",
-			description: "Node id",
-			required: true
-		},
-		json: {
-			type: "boolean",
-			description: "Print JSON",
-			default: false
-		}
-	},
-	run: ({ args }) => {
-		const cwd = process.cwd();
-		if (refusedBuiltin([args.workflow], cwd)) return;
-		const result = explainNode(workflowArg(args.workflow, cwd).file, args.node, cwd);
-		if (!result.ok) {
-			for (const line of result.lines) process.stderr.write(`${line}\n`);
-			process.exitCode = 1;
-			return;
-		}
-		if (args.json) write(JSON.stringify(result.explanation, void 0, 2));
-		else for (const line of formatExplanation(result.explanation)) write(line);
-	}
-});
-const context = defineCommand({
-	meta: {
-		name: "context",
-		description: "Inspect the context Ork compiles for each node"
-	},
-	subCommands: { explain }
-});
-export { validate as a, warningLines as c, loadWorkflow as i, explainNode as n, validateFile as o, formatReport as r, walkLoaded as s, context as t };