reposets 2.0.4 → 3.0.0

package/index.js

@@ -1,4 +1,4 @@
 import { ConfigSchema } from "./schemas/config.js";
-import { CONFIG_FILENAME, ConfigFlagNotFound, ReposetsConfigFile, makeConfigFilesLive } from "./services/ConfigFiles.js";
+import { CONFIG_FILENAME, ConfigFlagMissingConfig, ConfigFlagNotFound, ReposetsConfigFile, makeConfigFilesLive } from "./services/ConfigFiles.js";
 
-export { CONFIG_FILENAME, ConfigFlagNotFound, ConfigSchema, ReposetsConfigFile, makeConfigFilesLive };
+export { CONFIG_FILENAME, ConfigFlagMissingConfig, ConfigFlagNotFound, ConfigSchema, ReposetsConfigFile, makeConfigFilesLive };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "reposets",
-	"version": "2.0.4",
+	"version": "3.0.0",
 	"private": false,
 	"description": "CLI tool to sync GitHub repo settings, secrets and rulesets across personal repositories",
 	"keywords": [
@@ -52,12 +52,18 @@
 		"@effected/app": "^0.20.0",
 		"@effected/cli": "^0.11.0",
 		"@effected/config-file": "^0.14.0",
+		"@effected/env": "^0.1.0",
 		"@effected/github": "^0.15.0",
+		"@effected/glob": "^0.10.0",
+		"@effected/schemastore": "^0.20.0",
 		"@effected/store": "^0.12.0",
 		"@effected/toml": "^0.11.0",
+		"@effected/walker": "^0.15.0",
 		"@effected/xdg": "^0.9.0",
 		"blakejs": "^1.2.1",
-		"effect": "^4.0.0"
+		"effect": "^4.0.0",
+		"ink": "^7.1.1",
+		"react": "^19.3.0"
 	},
 	"engines": {
 		"node": ">=24.11.0"

package/schemas/hosted.js

@@ -0,0 +1,79 @@
+import { HostedSchema } from "@effected/schemastore";
+
+//#region src/schemas/hosted.ts
+/**
+* The version label both published JSON Schema documents carry.
+*
+* @remarks
+* `3.0` tracks the reposets 3.0.0 release that introduced versioned schemas.
+* The label names the TOML contract, not the package version: a later
+* reposets release that leaves both file shapes alone keeps `3.0`. A contract
+* change (a new required key, a removed or retyped key, a new `default`) is
+* answered by appending a new label to `versions` and leaving the `3.0` file
+* frozen on disk — `init` stamps the `3.0` URL into every config it scaffolds,
+* so editing that document in place would move a URL people pin.
+*
+* @public
+*/
+const SCHEMA_VERSION = "3.0";
+/**
+* Where the `reposets.config.toml` JSON Schema is hosted and which version is
+* current.
+*
+* @remarks
+* The one identity both sides derive from: `lib/configs/schemastore.config.ts`
+* builds the document at this `$id` (keyed by `name`), and `reposets init`
+* stamps `#:schema <$id>` into the config it scaffolds. Neither spells the URL
+* by hand, so the file the build writes and the URL a fresh config points at
+* cannot disagree. Served raw from `main` under the repository root's
+* `schemas/` directory — independent of the package layout — as
+* `schemas/<version>/config.json` (`appendVersion: false`, the version
+* directory alone names the version).
+*
+* @public
+*/
+const configSchemaHost = HostedSchema.github({
+	repo: "spencerbeggs/reposets",
+	path: "schemas",
+	name: "config",
+	versions: ["3.0"],
+	appendVersion: false
+});
+/**
+* Where the `reposets.credentials.toml` JSON Schema is hosted and which
+* version is current.
+*
+* @remarks
+* The credentials-file twin of {@link configSchemaHost}: same repository,
+* directory, layout and version label, so the two documents always move
+* together.
+*
+* @public
+*/
+const credentialsSchemaHost = HostedSchema.github({
+	repo: "spencerbeggs/reposets",
+	path: "schemas",
+	name: "credentials",
+	versions: ["3.0"],
+	appendVersion: false
+});
+/**
+* The `#:schema` directive `init` writes as the first line of a scaffolded
+* TOML file, followed by the blank line Tombi requires before the document.
+*
+* @remarks
+* `#:schema <url>` is the spelling both Taplo and Tombi read, and to every
+* TOML parser it is an ordinary comment — so the config and credentials
+* decoders never see it. The directive binds the file to one schema version
+* without depending on SchemaStore's catalog, which matches by file name and
+* may lag a release.
+*
+* @param host - the hosted schema the file is written against
+* @returns the directive line and its trailing blank line
+*
+* @public
+*/
+const schemaDirective = (host) => `#:schema ${host.$id}\n\n`;
+
+//#endregion
+export { configSchemaHost, credentialsSchemaHost, schemaDirective };

package/services/ConfigFiles.js

@@ -1,6 +1,6 @@
 import { ConfigSchema } from "../schemas/config.js";
 import { CredentialsSchema } from "../schemas/credentials.js";
-import { Data, Effect, FileSystem, Layer } from "effect";
+import { Data, Effect, FileSystem, Layer, Path } from "effect";
 import { AppConfig } from "@effected/app";
 import { ConfigFile, ConfigResolver, TomlCodec } from "@effected/config-file";
 
@@ -48,14 +48,13 @@ var ReposetsCredentialsFile = class extends ConfigFile.Service()("reposets/Crede
 * are covered by a `StructWithRest` rest schema, so they are not excess;
 * verified here and pinned by a test upstream.
 *
-* **Applied to credentials only, for now.** The config file keeps lenient
-* decoding because `doctor` diagnoses unknown keys with nearest-match
-* suggestions — strictly better output than a decode failure — and it locates
-* the file through `discover`, which decodes. Making the load strict means
-* `discover` fails and `doctor` reports "no config found" for a file that is
-* present and one character wrong, losing the diagnosis exactly when it is
-* wanted. Turning it on for config needs `doctor` to locate the file without
-* decoding first.
+* **Applied to both files.** Strict config decoding was once held back
+* because `doctor` found the config through `discover`, which decodes: a
+* strict load would have made a file that is present and one key wrong look
+* absent, losing the diagnosis exactly when it is wanted. `doctor` now keeps
+* `discover`'s failure as the structured issue it reports, and locates the
+* file on its own (`locateConfig`) without decoding, so its nearest-match
+* suggestions survive a strict load.
 */
 const STRICT_KEYS = {
 	onExcessProperty: "error",
@@ -105,20 +104,61 @@ var ConfigFlagNotFound = class extends Data.TaggedError("ConfigFlagNotFound") {
 	}
 };
 /**
+* Raised when `--config` names a directory that holds no `reposets.config.toml`.
+*
+* @remarks
+* The sibling of {@link ConfigFlagNotFound}, for the case it cannot see: the
+* path exists, so the existence check passes, but the directory resolver then
+* finds nothing and — being a probe with `never` in its error channel — falls
+* through to `AppConfig`'s XDG tier. `reposets doctor --config ./empty-dir`
+* would report on the user's XDG config, a different file from the one asked
+* about, with nothing to say so. An explicit request fails loudly here for the
+* same reason a missing path does.
+*
+* A separate tag rather than a widened `ConfigFlagNotFound`, because the two
+* call for different fixes — a mistyped path, versus a right directory with
+* the file missing or misnamed — and the message names both the directory and
+* the filename it looked for. Both are paths the user typed or a fixed name;
+* nothing secret reaches the message.
+*
+* @public
+*/
+var ConfigFlagMissingConfig = class extends Data.TaggedError("ConfigFlagMissingConfig") {
+	/**
+	* @remarks
+	* As on {@link ConfigFlagNotFound}: without it the error renders as a bare
+	* tag and the directory never reaches the log line.
+	*/
+	get message() {
+		return `--config directory has no ${this.filename}: ${this.dir}`;
+	}
+};
+/**
 * Builds the resolver tiers that must win over `AppConfig`'s own XDG chain.
 *
 * @remarks
 * `AppConfig.layer` prepends these, in order, ahead of `XdgConfig.resolver` and
 * the native-directory probe, so only the higher-priority tiers appear here.
+*
+* A directory is checked for the config file by existence only, not decoded:
+* a file that is present but invalid must still resolve, so `doctor` can
+* diagnose it and a command can report its decode error against the right path.
 */
 const resolversFor = (configFlag) => Effect.gen(function* () {
 	if (configFlag === void 0) return [ConfigResolver.upwardWalk({ filename: CONFIG_FILENAME })];
-	const info = yield* (yield* FileSystem.FileSystem).stat(configFlag).pipe(Effect.option);
+	const fs = yield* FileSystem.FileSystem;
+	const info = yield* fs.stat(configFlag).pipe(Effect.option);
 	if (info._tag === "None") return yield* new ConfigFlagNotFound({ path: configFlag });
-	return info.value.type === "Directory" ? [ConfigResolver.staticDir({
+	if (info.value.type !== "Directory") return [ConfigResolver.explicitPath(configFlag)];
+	const path = yield* Path.Path;
+	if (!(yield* fs.exists(path.join(configFlag, "reposets.config.toml")).pipe(Effect.orElseSucceed(() => false)))) return yield* new ConfigFlagMissingConfig({
+		dir: configFlag,
+		filename: CONFIG_FILENAME
+	});
+	return [ConfigResolver.staticDir({
 		dir: configFlag,
 		filename: CONFIG_FILENAME
-	})] : [ConfigResolver.explicitPath(configFlag)];
+	})];
 });
 /**
 * Builds the config-file layer for one invocation's `--config` flag.
@@ -138,4 +178,4 @@ const makeConfigFilesLive = (configFlag) => Layer.unwrap(Effect.map(resolversFor
 })));
 
 //#endregion
-export { CONFIG_FILENAME, CREDENTIALS_FILENAME, ConfigFlagNotFound, CredentialsFilesLive, ReposetsConfigFile, ReposetsCredentialsFile, makeConfigFilesLive };
+export { CONFIG_FILENAME, CREDENTIALS_FILENAME, ConfigFlagMissingConfig, ConfigFlagNotFound, CredentialsFilesLive, ReposetsConfigFile, ReposetsCredentialsFile, makeConfigFilesLive };

package/services/SyncLogger.js

@@ -1,4 +1,6 @@
-import { Console, Context, Effect, Layer, Ref } from "effect";
+import { Console, Context, Effect, Layer, PubSub, Ref } from "effect";
+import { CliTheme, Fmt, Status } from "@effected/cli";
+import { Audience } from "@effected/env";
 
 //#region src/services/SyncLogger.ts
 /** Plural forms the naive `+ "s"` gets wrong. */
@@ -41,14 +43,28 @@ function pluralize(resource, count) {
 * out-of-band edit happens to match the config. The tool has no work to do; the
 * human still changed something, and staying quiet would hide it.
 *
+* **Every action line leads with a status glyph**, from the kit's core
+* vocabulary: a change made is `success`, a dry run's `would …` is `info`, a
+* deletion and a drift are `warning`, a failure is `failure`, a skip is `skip`.
+* The glyph is painted for a person; an agent gets it unpainted and the text
+* plain, exactly as `CliMessage` does it. A failure's glyph is never painted:
+* it goes through the logger, which strips every escape a program logs. Headers
+* (`group:`, `repo:`) take none — they are structure, not outcomes. The glyph
+* sits after the indent and before the padded verb, so the verbs still line
+* up with each other.
+*
 * **The report is the product; failures are diagnostics.** What a run did —
 * group and repository headers, every operation, every drift line, the closing
 * "Sync complete!" — is the output of `sync` and `drift`, so it is written with
 * `Console.log` to stdout, where `reposets drift > report.txt` captures it.
-* Failures are emitted with `Effect.logError`, which the CLI logger
-* (`CliLogger.layer()`) routes to stderr, so they stay on the terminal when
-* stdout is redirected. A consequence worth knowing: `--log-level` filters
-* diagnostics only — it no longer silences the report.
+* Failures are emitted with `Effect.logError`, which the CLI logger routes to
+* stderr, so they stay on the terminal when stdout is redirected. A consequence
+* worth knowing: `--log-level` filters diagnostics only — it does not silence
+* the report.
+*
+* Both go through the fiber's `Console`, which is the seam a live progress view
+* uses: providing its `logConsole` around the run puts every one of these lines
+* above the redrawing frame without this service knowing a view exists.
 *
 * @public
 */
@@ -57,18 +73,44 @@ var SyncLogger = class extends Context.Service()("reposets/SyncLogger") {};
 * Build a live logger for one run.
 *
 * @remarks
-* A factory rather than a bare layer because both settings are per-invocation:
-* they come from the `--dry-run` and `--debug` flags, which are only known once
-* the command has parsed.
+* A factory rather than a bare layer because its settings are per-invocation:
+* they come from the `--dry-run` and `--debug` flags, and the event sink from
+* whether this run draws a view — all known only once the command has parsed.
+*
+* Requires `CliTheme` and `Audience`, read once when the layer builds, to paint
+* the status glyphs; under the bin both come from the environment
+* `CliRuntime.main` builds.
 *
 * @public
 */
 function SyncLoggerLive(config) {
-	const { dryRun, debug } = config;
+	const { dryRun, debug, events } = config;
 	return Layer.effect(SyncLogger, Effect.gen(function* () {
+		const theme = yield* CliTheme;
+		const audience = yield* Audience;
 		const errors = yield* Ref.make([]);
 		const currentRepo = yield* Ref.make("");
-		const emit = (line) => Console.log(line);
+		const publish = (event) => events === void 0 ? Effect.void : PubSub.publish(events, event);
+		/**
+		* A status glyph for a report line on stdout: painted for a person,
+		* plain for an agent — who never gets an escape, whatever the terminal
+		* could do.
+		*/
+		const mark = (status) => audience.kind === "agent" ? Status.core.glyph(status, theme.glyphs) : theme.status(Status.core, status);
+		/**
+		* A status glyph for a failure line, never painted.
+		*
+		* @remarks
+		* Failures go through `Effect.logError`, and the kit's logger sanitises
+		* every line a program logs — escapes included — so a painted glyph
+		* would arrive as the bare glyph anyway. Painting it here would only be
+		* a promise the logger does not keep. The glyph itself survives, and in
+		* the ASCII set it is the word `[FAIL]`.
+		*/
+		const failureMark = Status.core.glyph("failure", theme.forStream("stderr").glyphs);
+		const emit = (line) => Console.log(Fmt.sanitize(line));
+		/** An action line: indent, glyph, then the padded verb and its content. */
+		const action = (status, body) => Console.log(`    ${mark(status)} ${Fmt.sanitize(body)}`);
 		/**
 		* Failures, on the error channel.
 		*
@@ -87,34 +129,69 @@ function SyncLoggerLive(config) {
 		* concatenated directly, with no separating space.
 		*/
 		const formatVerb = (pastTense, presentTense) => dryRun ? `would ${presentTense}`.padEnd(14) : pastTense.padEnd(8);
+		/** A change made reads as done; the same change on a dry run, as information. */
+		const changeStatus = dryRun ? "info" : "success";
 		return {
+			runStart: (total) => publish({
+				_tag: "RunStarted",
+				total,
+				dryRun
+			}),
 			groupStart: (name, selected, declared) => {
 				const scope = selected === declared ? `${selected} ${selected === 1 ? "repo" : "repos"}` : `${selected} of ${declared} ${declared === 1 ? "repo" : "repos"}`;
-				return emit(`group: ${name} (${scope})`);
+				return emit(`group: ${name} (${scope})`).pipe(Effect.andThen(publish({
+					_tag: "GroupStarted",
+					name,
+					selected,
+					declared
+				})));
 			},
 			repoStart: (owner, repo) => {
 				const repoSlug = `${owner}/${repo}`;
-				return Ref.set(currentRepo, repoSlug).pipe(Effect.andThen(emit(`  repo: ${repoSlug}`)));
+				return Ref.set(currentRepo, repoSlug).pipe(Effect.andThen(emit(`  repo: ${repoSlug}`)), Effect.andThen(publish({
+					_tag: "RepoStarted",
+					slug: repoSlug
+				})));
 			},
 			settingsApplied: (fields) => {
 				const named = [...fields].sort();
 				const detail = named.length === 0 ? "" : named.length <= 6 ? ` (${named.join(", ")})` : ` (${named.length} fields: ${named.slice(0, 5).join(", ")}, …)`;
-				return emit(`    ${formatVerb("applied", "apply")}settings${detail}`);
+				return action(changeStatus, `${formatVerb("applied", "apply")}settings${detail}`).pipe(Effect.andThen(publish({
+					_tag: "Operation",
+					verb: "apply",
+					resource: "settings",
+					count: 1
+				})));
 			},
 			cleanupSummary: (resource, count, names) => {
 				const suffix = names.length > 0 ? ` (${names.join(", ")})` : "";
-				return emit(`    ${formatVerb("deleted", "delete")}${count} ${pluralize(resource, count)}${suffix}`);
+				return action("warning", `${formatVerb("deleted", "delete")}${count} ${pluralize(resource, count)}${suffix}`).pipe(Effect.andThen(publish({
+					_tag: "Operation",
+					verb: "delete",
+					resource,
+					count
+				})));
 			},
 			syncOperation: (verb, resource, name, detail, source) => {
 				const nameStr = name ? ` ${name}` : "";
 				const suffix = detail ? ` ${detail}` : "";
 				const sourceSuffix = source && debug ? ` <- ${source}` : "";
-				return emit(`    ${formatVerb(verb, verb)}${resource}${nameStr}${suffix}${sourceSuffix}`);
+				return action(verb === "skip" ? "skip" : verb === "delete" ? "warning" : changeStatus, `${formatVerb(verb, verb)}${resource}${nameStr}${suffix}${sourceSuffix}`).pipe(Effect.andThen(publish({
+					_tag: "Operation",
+					verb,
+					resource,
+					count: 1
+				})));
 			},
 			driftDetected: (resource, name, drift) => {
 				const consequence = !drift.needsApply ? "already matches config, nothing written" : dryRun ? "would overwrite" : "overwritten";
 				const fingerprints = debug ? ` <- applied ${drift.applied} live ${drift.live}` : "";
-				return emit(`    ${"drift".padEnd(8)}${resource} ${name} changed outside reposets — ${consequence}${fingerprints}`);
+				return action("warning", `${"drift".padEnd(8)}${resource} ${name} changed outside reposets — ${consequence}${fingerprints}`).pipe(Effect.andThen(publish({
+					_tag: "Drift",
+					resource,
+					name,
+					needsApply: drift.needsApply
+				})));
 			},
 			syncError: (context, message) => Effect.gen(function* () {
 				const repo = yield* Ref.get(currentRepo);
@@ -123,16 +200,25 @@ function SyncLoggerLive(config) {
 					context,
 					message
 				}]);
-				yield* emitError(`    error   ${context}: ${message}`);
+				yield* emitError(`    ${failureMark} ${Fmt.sanitize(`error   ${context}: ${message}`)}`);
+				yield* publish({
+					_tag: "Error",
+					repo,
+					context,
+					message
+				});
 			}),
-			finish: () => Effect.gen(function* () {
+			finish: (summary) => Effect.gen(function* () {
 				const errs = yield* Ref.get(errors);
-				if (errs.length === 0) {
-					yield* emit("Sync complete!");
-					return;
+				if (errs.length === 0) yield* Console.log(`${mark("success")} Sync complete!`);
+				else {
+					yield* emitError(`${failureMark} Sync complete with ${errs.length} ${errs.length === 1 ? "error" : "errors"}:`);
+					for (const err of errs) yield* emitError(Fmt.sanitize(err.repo === "" ? `  ${err.context} — ${err.message}` : `  ${err.repo}: ${err.context} — ${err.message}`));
 				}
-				yield* emitError(`Sync complete with ${errs.length} ${errs.length === 1 ? "error" : "errors"}:`);
-				for (const err of errs) yield* emitError(err.repo === "" ? `  ${err.context} — ${err.message}` : `  ${err.repo}: ${err.context} — ${err.message}`);
+				yield* publish({
+					_tag: "RunEnded",
+					...summary
+				});
 			})
 		};
 	}));

package/store/SyncJournal.js

@@ -59,6 +59,7 @@ var SyncJournal = class extends Context.Service()("reposets/SyncJournal", { make
 							ORDER BY r.rowid DESC
 							LIMIT ${options.limit}
 						`,
+		runIds: () => sql`SELECT id FROM sync_run`.pipe(Effect.map((rows) => rows.map((row) => row.id))),
 		changesFor: (runId) => sql`
 					SELECT repo, kind, name, action, detail
 					FROM sync_change

package/store/files.js

@@ -0,0 +1,25 @@
+//#region src/store/files.ts
+/**
+* The state database's file name, under the XDG state directory.
+*
+* @remarks
+* Passed explicitly to `AppStore.layer` rather than left to its default, so
+* the name the database is opened under and the name `nuke` and `doctor` look
+* for are one constant and cannot drift apart.
+*
+* @public
+*/
+const STATE_DB_FILENAME = "store.db";
+/**
+* The cache database's file name, under the XDG cache directory.
+*
+* @remarks
+* Passed explicitly to `AppCache.layer` for the same reason as
+* {@link STATE_DB_FILENAME}.
+*
+* @public
+*/
+const CACHE_DB_FILENAME = "cache.db";
+
+//#endregion
+export { CACHE_DB_FILENAME, STATE_DB_FILENAME };