@okfit/cli 0.1.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@okfit/cli",
-	"version": "0.1.0",
+	"version": "0.3.0",
 	"private": false,
 	"description": "The okfit command line: validate, lint, index, and inspect Open Knowledge Format (OKF) bundles.",
 	"keywords": [
@@ -31,16 +31,31 @@
 			"import": "./index.js",
 			"default": "./index.js"
 		},
+		"./main": {
+			"types": "./main.d.ts",
+			"import": "./main.js",
+			"default": "./main.js"
+		},
 		"./package.json": "./package.json"
 	},
 	"bin": {
 		"okfit": "bin/okfit.js"
 	},
 	"dependencies": {
-		"@effect/platform-node": "4.0.0-rc.109",
-		"@okfit/core": "0.1.0",
-		"@okfit/profiles": "0.1.0",
-		"effect": "4.0.0-rc.109"
+		"@effect/platform-node": "4.0.0-rc.112",
+		"@effected/cli": "^0.3.1",
+		"@effected/config-file": "^0.7.0",
+		"@effected/git": "^0.12.0",
+		"@effected/glob": "^0.5.0",
+		"@effected/jsonc": "^0.9.0",
+		"@effected/markdown": "^0.9.1",
+		"@effected/toml": "^0.6.0",
+		"@effected/walker": "^0.7.0",
+		"@effected/yaml": "^0.14.0",
+		"@okfit/core": "0.2.0",
+		"@okfit/engine": "0.1.0",
+		"@okfit/profiles": "0.2.0",
+		"effect": "4.0.0-rc.112"
 	},
 	"engines": {
 		"node": ">=24.11.0"

package/render/context.js

@@ -0,0 +1,29 @@
+//#region src/render/context.ts
+/**
+* The `human` format: a short header block, then one line per type and one
+* per tag. Pure; the caller pipes each line through `Console.log`.
+*
+* The `profile:` line reads `profile: (none) (requested NAME, unknown)`
+* when `profile` and `profile_requested` disagree over an actually-unknown
+* profile — never for the `"none"` or no-config cases, where a `null`
+* `profile` is expected, not an error.
+*
+* @public
+*/
+const humanContext = (envelope) => [
+	`project root: ${envelope.project_root}`,
+	`bundle root: ${envelope.bundle_root}`,
+	`config: ${envelope.config_path ?? "(none)"}`,
+	envelope.profile === null && envelope.profile_requested !== null && envelope.profile_requested !== "none" ? `profile: (none) (requested ${envelope.profile_requested}, unknown)` : `profile: ${envelope.profile ?? "(none)"}`,
+	`index.md: ${envelope.index_path} (${envelope.index_exists ? "exists" : "missing"})`,
+	`agent: ${envelope.actors.agent ?? "(unset)"}`,
+	"",
+	"types:",
+	...envelope.types.map((t) => `  ${t.name}  ${t.description ?? ""}`),
+	"",
+	"tags:",
+	...envelope.tags.map((t) => `  ${t.name}  ${t.description ?? ""}`)
+];
+
+//#endregion
+export { humanContext };

package/render/human.js

@@ -0,0 +1,68 @@
+import { sort } from "@okfit/engine";
+
+//#region src/render/human.ts
+/** The ANSI escape character, built from its code point so the source never carries a raw control byte. */
+const ESC = String.fromCharCode(27);
+/** ANSI SGR codes for the severity word only (K-19); reset after, never applied elsewhere. */
+const SEVERITY_COLOR = {
+	error: `${ESC}[31m`,
+	warning: `${ESC}[33m`,
+	info: `${ESC}[36m`
+};
+const RESET = `${ESC}[0m`;
+const colorize = (severity, color) => color ? `${SEVERITY_COLOR[severity]}${severity}${RESET}` : severity;
+/**
+* K-16. With a range:
+* `<file>:<range.line + 1>:<range.character + 1> <severity> <code> <message>`.
+* Without one: `<file> <severity> <code> <message>`. `file: ""` renders as
+* the literal `(bundle)`. Core's range is zero-based (D-32,
+* `CORE/Diagnostic.ts:49-57`); the `+ 1`s here are the only place it becomes
+* one-based. Colour, when `color` is `true`, wraps ONLY the severity word
+* (K-19) — never the code, the path, or the message.
+*
+* @public
+*/
+const line = (diagnostic, options) => {
+	const color = options?.color ?? false;
+	const file = diagnostic.file === "" ? "(bundle)" : diagnostic.file;
+	const severity = colorize(diagnostic.severity, color);
+	return `${diagnostic.range === void 0 ? file : `${file}:${diagnostic.range.line + 1}:${diagnostic.range.character + 1}`} ${severity} ${diagnostic.code} ${diagnostic.message}`;
+};
+/**
+* `sort` then `line` over the whole set: the exact stdout body of
+* `--format human`, one array element per stdout line.
+*
+* @public
+*/
+const human = (diagnostics, options) => sort(diagnostics).map((d) => line(d, options));
+/**
+* K-20, verbatim and unpluralised —
+* `<E> errors, <W> warnings, <I> info in <N> concepts (<root>)`. `root` is
+* pre-rendered by the caller: relative to cwd when under it, absolute
+* otherwise (K-51).
+*
+* @public
+*/
+const summary = (counts, root) => `${counts.errors} errors, ${counts.warnings} warnings, ${counts.info} info in ${counts.concepts} concepts (${root})`;
+/**
+* The one K-51 display-path rule, shared by both `commands/validate.ts`'s
+* `summary` root and `commands/init.ts`'s success line: `target` relative
+* to `cwd` when it is under it, absolute otherwise. Three cases, in order:
+*
+* 1. `target === cwd` (`path.relative` returns `""`): the literal `.`.
+* 2. The relative form starts with `..`, or is itself absolute (a target on
+*    a different root than `cwd`, where `Path.relative` can return an
+*    absolute path unchanged depending on the platform): `target`
+*    unchanged, absolute.
+* 3. Otherwise: the relative form.
+*
+* @internal
+*/
+const displayRoot = (cwd, target, path) => {
+	const relative = path.relative(cwd, target);
+	if (relative === "") return ".";
+	return relative.startsWith("..") || path.isAbsolute(relative) ? target : relative;
+};
+
+//#endregion
+export { displayRoot, human, line, summary };

package/render/sync.js

@@ -0,0 +1,41 @@
+//#region src/render/sync.ts
+/** Contract §9.2's fixed reason-sentence table, closed over `SkipReason`. */
+const REASON_SENTENCE = {
+	untracked: "not tracked by git",
+	dirty: "has uncommitted changes",
+	unborn: "the repository has no commits yet",
+	"generated-missing": "has no generated block",
+	"generated-unsupported": "generated.at is a shape sync cannot edit; edit it by hand",
+	"log-unparseable": "log.md could not be parsed; see okfit validate"
+};
+const humanMode = (name, mode) => {
+	if (!mode.selected) return [`${name}: not selected`];
+	const lines = [`${name}:`];
+	for (const id of mode.written) lines.push(`  wrote ${id}`);
+	for (const id of mode.unchanged) lines.push(`  unchanged ${id}`);
+	for (const entry of mode.skipped) lines.push(`  skipped ${entry.id}: ${REASON_SENTENCE[entry.reason]}`);
+	return lines;
+};
+/**
+* Contract §9.2 (design §2): per mode, three lists, then a one-line
+* summary. A mode `--only` excluded from renders as `not selected` rather
+* than three empty lists — an implementer choice within the fixed JSON
+* shape (§14 makes no ruling on the human half; this is cosmetic).
+*
+* @public
+*/
+const humanSync = (result) => {
+	const lines = [
+		...humanMode("generated", result.generated),
+		...humanMode("index", result.index),
+		...humanMode("log", result.log)
+	];
+	const totalWritten = result.generated.written.length + result.index.written.length + result.log.written.length;
+	const totalUnchanged = result.generated.unchanged.length + result.index.unchanged.length + result.log.unchanged.length;
+	const totalSkipped = result.generated.skipped.length + result.index.skipped.length + result.log.skipped.length;
+	lines.push(result.dryRun ? `would write ${totalWritten}, unchanged ${totalUnchanged}, skipped ${totalSkipped} (dry run, nothing written)` : `wrote ${totalWritten}, unchanged ${totalUnchanged}, skipped ${totalSkipped}`);
+	return lines;
+};
+
+//#endregion
+export { humanSync };

package/render/verify.js

@@ -0,0 +1,29 @@
+//#region src/render/verify.ts
+/**
+* Indent every line of `fragment` two spaces for display under a
+* `would write:` header, dropping the single trailing empty line a
+* newline-terminated fragment produces on split (I3).
+*/
+const indentFragment = (fragment) => {
+	const lines = fragment.split(/\r\n|\n/);
+	return (lines[lines.length - 1] === "" ? lines.slice(0, -1) : lines).map((line) => `  ${line}`);
+};
+/**
+* V-11's human output: one line per fact. One `already verified` line per
+* prior entry by the same actor, in list order (V-2 says "entries",
+* plural), then the success line. A prior entry by a DIFFERENT actor is
+* not called out: it stays on disk untouched (V-1) and is simply not this
+* line's subject. Under `--dry-run` (I3), a `would write:` header and the
+* exact fragment a real run would splice in follow, so the preview
+* exercises — and shows — the same edit the write path would make.
+*
+* @public
+*/
+const humanVerify = (input) => [
+	...input.priorAt.map((at) => `already verified by ${input.by} at ${at}; appending`),
+	input.dryRun ? `would verify ${input.id} by ${input.by} at ${input.at} (dry run, nothing written)` : `verified ${input.id} by ${input.by} at ${input.at}`,
+	...input.dryRun ? ["would write:", ...indentFragment(input.fragment)] : []
+];
+
+//#endregion
+export { humanVerify };

package/version.js

@@ -0,0 +1,14 @@
+//#region src/version.ts
+/**
+* The version string reported by `okfit --version`. `@savvy-web/bundler`
+* replaces `process.env.__PACKAGE_VERSION__` with this package's own
+* version at build time (K-32), so a release can never desync from the
+* printed version. `"0.0.0"` is the unbuilt-source fallback and reads as
+* dev mode.
+*
+* @public
+*/
+const CLI_VERSION = "0.3.0";
+
+//#endregion
+export { CLI_VERSION };