deweyou-cli 0.2.1

package/dist/init-ClloZBVB.mjs

@@ -0,0 +1,353 @@
+import { cachePaths, n as writeJson, t as readJson } from "./cache-CBEKVQeD.mjs";
+import { cp, lstat, mkdir, readFile, realpath, rename, rm, symlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, relative } from "node:path";
+//#region src/cli/agents-md.ts
+const DEWEYOU_SECTION_START = "<!-- deweyou-agent:start -->";
+const DEWEYOU_SECTION_END = "<!-- deweyou-agent:end -->";
+const DEWEY_SECTION = `${DEWEYOU_SECTION_START}
+## Dewey Workflow
+
+This repository uses Dewey's personal agent workflow. Inspect \`.agents/\` before making changes, then run \`deweyou-cli agent context --format markdown\` and follow the returned rules, skill index, asset paths, and runtime notices.
+${DEWEYOU_SECTION_END}`;
+async function upsertAgentsSection(repoRoot) {
+	const path = join(repoRoot, "AGENTS.md");
+	const next = upsertSection(await readAgentsFile(path));
+	await writeFile(path, next);
+	return next;
+}
+async function readAgentsFile(path) {
+	try {
+		return await readFile(path, "utf8");
+	} catch (error) {
+		if (!(error instanceof Error) || !("code" in error)) throw error;
+		if (error.code === "ENOENT") return "";
+		throw error;
+	}
+}
+function upsertSection(contents) {
+	const markedSection = new RegExp(`${escapeRegex(DEWEYOU_SECTION_START)}[\\s\\S]*?${escapeRegex(DEWEYOU_SECTION_END)}`);
+	if (markedSection.test(contents)) return ensureTrailingNewline(contents.replace(markedSection, DEWEY_SECTION));
+	const trimmed = contents.trimEnd();
+	if (!trimmed) return `${DEWEY_SECTION}\n`;
+	return `${trimmed}\n\n${DEWEY_SECTION}\n`;
+}
+function escapeRegex(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function ensureTrailingNewline(value) {
+	return value.endsWith("\n") ? value : `${value}\n`;
+}
+//#endregion
+//#region src/cli/init.ts
+const VALID_MODES = new Set([
+	"link",
+	"copy",
+	"pointer"
+]);
+const SAFE_ID = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+async function initRepo({ repoRoot = process.cwd(), homeDir = homedir(), mode = "link", selected, force = false, dryRun = false } = {}) {
+	if (!selected) throw new Error("selected assets are required");
+	validateMode(mode);
+	const paths = cachePaths({ homeDir });
+	const registry = await readCachedRegistry(paths.assetsRoot);
+	const cacheManifest = await readCacheManifest(paths.manifestPath);
+	const assets = normalizeSelected(selected);
+	const agentsRoot = join(repoRoot, ".agents");
+	validateSelectedAssets(registry, assets);
+	const plan = await buildInitPlan({
+		repoRoot,
+		agentsRoot,
+		assetsRoot: paths.assetsRoot,
+		registry,
+		assets,
+		mode
+	});
+	if (mode !== "pointer") await validateDestinationSafety({
+		plan,
+		manifestPath: join(agentsRoot, "manifest.json"),
+		assetsRoot: paths.assetsRoot,
+		force
+	});
+	const manifest = {
+		mode,
+		source: cacheManifest.source,
+		cacheRoot: paths.assetsRoot,
+		assets,
+		assetSnapshot: snapshotSelectedAssetMetadata(registry, assets),
+		initializedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	if (dryRun) return {
+		dryRun: true,
+		mode,
+		source: cacheManifest.source,
+		cacheRoot: paths.assetsRoot,
+		assets,
+		assetSnapshot: snapshotSelectedAssetMetadata(registry, assets),
+		files: plan.files
+	};
+	await mkdir(agentsRoot, { recursive: true });
+	if (mode !== "pointer") await installAssets(plan.assets);
+	await writeJson(join(agentsRoot, "manifest.json"), manifest);
+	await upsertAgentsSection(repoRoot);
+	return manifest;
+}
+async function runInit(flags = {}, { promptForInit } = {}) {
+	const homeDir = flags.homeDir ?? homedir();
+	const repoRoot = flags.repoRoot ?? process.cwd();
+	const registry = await readCachedRegistry(cachePaths({ homeDir }).assetsRoot);
+	const scripted = hasScriptedSelectionFlags(flags);
+	let mode = flags.mode ?? "link";
+	let selected;
+	validateMode(mode);
+	if (flags.yes && !scripted) throw new Error("--yes requires --all, --skills, or --rules");
+	if (scripted) selected = flags.all ? selectAll(registry) : {
+		skills: flags.skills ?? [],
+		rules: flags.rules ?? []
+	};
+	else {
+		const prompted = await (promptForInit ?? await loadPromptForInit())({
+			registry,
+			repoRoot,
+			mode: flags.mode
+		});
+		mode = prompted.mode;
+		selected = prompted.selected;
+	}
+	if (!hasSelectedAssets(selected)) throw new Error("No assets selected. Pass --all, --skills, or --rules, or run interactive setup.");
+	const manifest = await initRepo({
+		repoRoot,
+		mode,
+		selected,
+		force: flags.force ?? false,
+		dryRun: flags.dryRun ?? false,
+		homeDir
+	});
+	if (flags.dryRun) {
+		console.log("Dewey workflow init plan:");
+		for (const file of manifest.files) console.log(`- ${file}`);
+	} else console.log("Initialized Dewey workflow for this repository.");
+	return manifest;
+}
+async function loadPromptForInit() {
+	const { promptForInit } = await import("./prompts-DVRcV560.mjs");
+	return promptForInit;
+}
+async function readCachedRegistry(assetsRoot) {
+	try {
+		const registry = JSON.parse(await readFile(join(assetsRoot, "registry.json"), "utf8"));
+		return {
+			...registry,
+			assets: {
+				/* v8 ignore next -- legacy cache manifests may omit collections */
+				skills: registry.assets?.skills ?? {},
+				/* v8 ignore next -- legacy cache manifests may omit collections */
+				rules: registry.assets?.rules ?? {}
+			}
+		};
+	} catch (error) {
+		/* v8 ignore next -- defensive guard for non-Node filesystem errors */
+		if (!(error instanceof Error) || !("code" in error)) throw error;
+		if (error.code === "ENOENT") throw new Error("Dewey asset cache is missing. Run `deweyou-cli agent update` first.");
+		/* v8 ignore next -- invalid JSON and non-missing read errors should bubble */
+		throw error;
+	}
+}
+async function readCacheManifest(manifestPath) {
+	const manifest = await readJson(manifestPath, null);
+	if (!manifest?.source || typeof manifest.source.root !== "string") throw new Error("Dewey asset cache manifest is missing source metadata. Run `deweyou-cli agent update` first.");
+	return manifest;
+}
+function normalizeSelected(selected) {
+	return {
+		skills: [...selected.skills ?? []],
+		rules: [...selected.rules ?? []]
+	};
+}
+function hasSelectedAssets(selected) {
+	if (!selected) return false;
+	return selected.skills.length > 0 || selected.rules.length > 0;
+}
+function hasScriptedSelectionFlags(flags) {
+	return Boolean(flags.all || flags.skills || flags.rules);
+}
+function validateMode(mode) {
+	if (typeof mode !== "string") throw new Error("mode must be one of link, copy, or pointer");
+	if (!VALID_MODES.has(mode)) throw new Error("mode must be one of link, copy, or pointer");
+}
+function validateSelectedAssets(registry, selected) {
+	for (const skill of selected.skills) {
+		if (!registry.assets.skills[skill]) throw new Error(`Unknown Dewey skill: ${skill}`);
+		validateAssetId(skill, "skill");
+	}
+	for (const rule of selected.rules) {
+		if (!registry.assets.rules[rule]) throw new Error(`Unknown Dewey rule: ${rule}`);
+		validateAssetId(rule, "rule");
+	}
+}
+function validateAssetId(id, kind) {
+	if (!SAFE_ID.test(id)) throw new Error(`Dewey ${kind} id must be kebab-case: ${id}`);
+}
+function selectAll(registry) {
+	return {
+		skills: Object.keys(registry.assets.skills),
+		rules: Object.keys(registry.assets.rules)
+	};
+}
+function snapshotSelectedAssetMetadata(registry, selected) {
+	return {
+		skills: Object.fromEntries(selected.skills.map((name) => [name, pickAssetMetadata(registry.assets.skills[name])])),
+		rules: Object.fromEntries(selected.rules.map((name) => [name, pickAssetMetadata(registry.assets.rules[name])]))
+	};
+}
+function pickAssetMetadata(asset) {
+	return {
+		description: asset.description,
+		hash: asset.hash
+	};
+}
+async function buildInitPlan({ repoRoot, agentsRoot, assetsRoot, registry, assets, mode }) {
+	const assetPlans = mode === "pointer" ? [] : await Promise.all([...assets.skills.map((id) => buildAssetPlan({
+		kind: "skill",
+		id,
+		source: join(assetsRoot, registry.assets.skills[id].path),
+		destination: join(agentsRoot, "skills", id),
+		mode
+	})), ...assets.rules.map((id) => buildAssetPlan({
+		kind: "rule",
+		id,
+		source: join(assetsRoot, registry.assets.rules[id].path),
+		destination: join(agentsRoot, "rules", `${id}.md`),
+		mode
+	}))]);
+	return {
+		assets: assetPlans,
+		files: [
+			...assetPlans.map((asset) => asset.destination),
+			join(agentsRoot, "manifest.json"),
+			join(repoRoot, "AGENTS.md")
+		]
+	};
+}
+async function buildAssetPlan({ kind, id, source, destination, mode }) {
+	return {
+		kind,
+		id,
+		source: await realpath(source),
+		destination,
+		mode
+	};
+}
+async function validateDestinationSafety({ plan, manifestPath, assetsRoot, force }) {
+	const previousManifest = await readJson(manifestPath, null);
+	const safeManifestDestinations = new Set(manifestDestinations(dirname(manifestPath), previousManifest));
+	for (const asset of plan.assets) await validateDestination(asset, {
+		assetsRoot,
+		force,
+		safeManifestDestinations
+	});
+}
+function manifestDestinations(agentsRoot, manifest) {
+	if (!manifest?.assets) return [];
+	return [...(manifest.assets.skills ?? []).map((id) => join(agentsRoot, "skills", id)), ...(manifest.assets.rules ?? []).map((id) => join(agentsRoot, "rules", `${id}.md`))];
+}
+async function validateDestination(asset, { assetsRoot, force, safeManifestDestinations }) {
+	let destinationStat;
+	try {
+		destinationStat = await lstat(asset.destination);
+	} catch (error) {
+		/* v8 ignore next -- defensive guard for non-Node filesystem errors */
+		if (!(error instanceof Error) || !("code" in error)) throw error;
+		if (error.code === "ENOENT") return;
+		/* v8 ignore next -- non-missing lstat errors should bubble to the caller */
+		throw error;
+	}
+	if (!force) throw new Error(`${asset.destination} already exists. Use --force to replace Dewey-managed asset files.`);
+	if (safeManifestDestinations.has(asset.destination) || destinationStat.isSymbolicLink() && await pointsIntoAssetsRoot(asset.destination, assetsRoot)) return;
+	throw new Error(`Refusing to replace non-Dewey-managed destination: ${asset.destination}`);
+}
+async function pointsIntoAssetsRoot(destination, assetsRoot) {
+	let destinationTarget;
+	try {
+		destinationTarget = await realpath(destination);
+	} catch (error) {
+		/* v8 ignore next -- defensive guard for non-Node filesystem errors */
+		if (!(error instanceof Error) || !("code" in error)) throw error;
+		if (error.code === "ENOENT") return false;
+		/* v8 ignore next -- non-missing realpath errors should bubble to the caller */
+		throw error;
+	}
+	const pathFromRoot = relative(await realpath(assetsRoot), destinationTarget);
+	return pathFromRoot === "" || !pathFromRoot.startsWith("..") && !isAbsolute(pathFromRoot);
+}
+async function installAssets(assets) {
+	for (const asset of assets) await installAsset(asset);
+}
+async function installAsset({ source, destination, mode }) {
+	const parent = dirname(destination);
+	const tempDestination = tempSibling(destination, "tmp");
+	const backupDestination = tempSibling(destination, "backup");
+	await mkdir(parent, { recursive: true });
+	try {
+		await rm(tempDestination, {
+			recursive: true,
+			force: true
+		});
+		await rm(backupDestination, {
+			recursive: true,
+			force: true
+		});
+		if (mode === "link") await symlink(source, tempDestination);
+		else await cp(source, tempDestination, {
+			recursive: true,
+			force: false,
+			errorOnExist: true
+		});
+		const hasExistingDestination = await pathExists(destination);
+		if (hasExistingDestination) await rename(destination, backupDestination);
+		try {
+			await rename(tempDestination, destination);
+		} catch (error) {
+			/* v8 ignore next -- defensive guard for non-Error filesystem failures */
+			if (!(error instanceof Error)) throw error;
+			if (hasExistingDestination) await restoreBackup(backupDestination, destination, error);
+			throw error;
+		}
+		if (hasExistingDestination) await rm(backupDestination, {
+			recursive: true,
+			force: true
+		});
+	} catch (error) {
+		await rm(tempDestination, {
+			recursive: true,
+			force: true
+		});
+		/* v8 ignore next -- cleanup is deterministic; original error is rethrown */
+		throw error;
+	}
+}
+function tempSibling(destination, label) {
+	return join(dirname(destination), `.${basename(destination)}.${label}-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+}
+async function pathExists(path) {
+	try {
+		await lstat(path);
+		return true;
+	} catch (error) {
+		/* v8 ignore next -- defensive guard for non-Node filesystem errors */
+		if (!(error instanceof Error) || !("code" in error)) throw error;
+		if (error.code === "ENOENT") return false;
+		/* v8 ignore next -- non-missing lstat errors should bubble to the caller */
+		throw error;
+	}
+}
+async function restoreBackup(backupDestination, destination, originalError) {
+	try {
+		await rename(backupDestination, destination);
+	} catch (restoreError) {
+		/* v8 ignore next -- restore failures are attached to the original error */
+		originalError.restoreError = restoreError;
+	}
+}
+//#endregion
+export { runInit };

package/dist/prompts-DVRcV560.mjs

@@ -0,0 +1,100 @@
+import { cancel, confirm, intro, isCancel, multiselect, note, select } from "@clack/prompts";
+//#region src/cli/prompts.ts
+const SETUP_MODES = [
+	{
+		value: "link",
+		label: "link",
+		hint: "Symlink assets from the Dewey cache."
+	},
+	{
+		value: "copy",
+		label: "copy",
+		hint: "Copy asset files into this repository."
+	},
+	{
+		value: "pointer",
+		label: "pointer",
+		hint: "Write only the manifest and AGENTS.md pointers."
+	}
+];
+const ASSET_SCOPES = [
+	{
+		value: "all",
+		label: "all",
+		hint: "Enable every cached skill and rule."
+	},
+	{
+		value: "custom",
+		label: "custom",
+		hint: "Choose skills and rules individually."
+	},
+	{
+		value: "skills",
+		label: "skills only",
+		hint: "Choose skills without installing rules."
+	},
+	{
+		value: "rules",
+		label: "rules only",
+		hint: "Choose rules without installing skills."
+	}
+];
+async function promptForInit({ registry, repoRoot, mode }) {
+	intro("Dewey Agent Setup");
+	note(repoRoot, "Repository");
+	const selectedMode = mode ?? await promptOrExit(select({
+		message: "Select setup mode",
+		options: SETUP_MODES
+	}));
+	const selected = await selectAssets({
+		registry,
+		scope: await promptOrExit(select({
+			message: "Select asset scope",
+			options: ASSET_SCOPES
+		}))
+	});
+	if (!await promptOrExit(confirm({ message: `Enable ${selected.skills.length} skill(s) and ${selected.rules.length} rule(s) using ${selectedMode} mode?` }))) exitCancelled();
+	return {
+		mode: selectedMode,
+		selected
+	};
+}
+async function selectAssets({ registry, scope }) {
+	if (scope === "all") return {
+		skills: Object.keys(registry.assets.skills),
+		rules: Object.keys(registry.assets.rules)
+	};
+	const selected = {
+		skills: [],
+		rules: []
+	};
+	if (scope === "custom" || scope === "skills") selected.skills = await promptOrExit(multiselect({
+		message: "Select skills",
+		options: assetOptions(registry.assets.skills),
+		required: false
+	}));
+	if (scope === "custom" || scope === "rules") selected.rules = await promptOrExit(multiselect({
+		message: "Select rules",
+		options: assetOptions(registry.assets.rules),
+		required: false
+	}));
+	return selected;
+}
+function assetOptions(assets) {
+	return Object.entries(assets).map(([name, asset]) => ({
+		value: name,
+		label: name,
+		hint: asset.description
+	}));
+}
+async function promptOrExit(prompt) {
+	const value = await prompt;
+	if (isCancel(value)) exitCancelled();
+	return value;
+}
+function exitCancelled() {
+	cancel("Dewey agent setup cancelled.");
+	process.exit(0);
+}
+//#endregion
+export { promptForInit };

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "deweyou-cli",
+  "version": "0.2.1",
+  "type": "module",
+  "description": "Dewey's personal agent workflow bootstrapper",
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "bin": {
+    "deweyou-cli": "./dist/deweyou.mjs"
+  },
+  "scripts": {
+    "build": "vp pack src/bin/deweyou.ts --out-dir dist --clean",
+    "prepare": "npm run build",
+    "release:prepare": "tsx scripts/prepare-release.ts",
+    "test": "vp test run",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "start": "tsx src/bin/deweyou.ts"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^25.5.2",
+    "@vitest/coverage-v8": "4.1.5",
+    "typescript": "^6.0.2",
+    "tsx": "^4.21.0",
+    "vitest": "4.1.5",
+    "vite-plus": "^0.1.21"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT"
+}