fabis-ralph-loop 0.1.0

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli.mjs

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from "citty";
+
+//#region src/cli.ts
+runMain(defineCommand({
+	meta: {
+		name: "fabis-ralph-loop",
+		description: "CLI for setting up and running Claude Ralph autonomous coding loops",
+		version: "0.1.0"
+	},
+	subCommands: {
+		init: () => import("./init.mjs").then((m) => m.default),
+		generate: () => import("./generate.mjs").then((m) => m.default),
+		start: () => import("./start.mjs").then((m) => m.default),
+		stop: () => import("./stop.mjs").then((m) => m.default),
+		restart: () => import("./restart.mjs").then((m) => m.default),
+		logs: () => import("./logs.mjs").then((m) => m.default),
+		run: () => import("./run.mjs").then((m) => m.default),
+		exec: () => import("./exec.mjs").then((m) => m.default)
+	}
+}));
+
+//#endregion
+export {  };
+//# sourceMappingURL=cli.mjs.map

package/dist/cli.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.mjs","names":[],"sources":["../src/cli.ts"],"sourcesContent":["#!/usr/bin/env node\nimport { defineCommand, runMain } from 'citty'\n\nconst main = defineCommand({\n  meta: {\n    name: 'fabis-ralph-loop',\n    description: 'CLI for setting up and running Claude Ralph autonomous coding loops',\n    version: '0.1.0',\n  },\n  subCommands: {\n    init: () => import('./commands/init.js').then((m) => m.default),\n    generate: () => import('./commands/generate.js').then((m) => m.default),\n    start: () => import('./commands/start.js').then((m) => m.default),\n    stop: () => import('./commands/stop.js').then((m) => m.default),\n    restart: () => import('./commands/restart.js').then((m) => m.default),\n    logs: () => import('./commands/logs.js').then((m) => m.default),\n    run: () => import('./commands/run.js').then((m) => m.default),\n    exec: () => import('./commands/exec.js').then((m) => m.default),\n  },\n})\n\nrunMain(main)\n"],"mappings":";;;;AAqBA,QAlBa,cAAc;CACzB,MAAM;EACJ,MAAM;EACN,aAAa;EACb,SAAS;EACV;CACD,aAAa;EACX,YAAY,OAAO,cAAsB,MAAM,MAAM,EAAE,QAAQ;EAC/D,gBAAgB,OAAO,kBAA0B,MAAM,MAAM,EAAE,QAAQ;EACvE,aAAa,OAAO,eAAuB,MAAM,MAAM,EAAE,QAAQ;EACjE,YAAY,OAAO,cAAsB,MAAM,MAAM,EAAE,QAAQ;EAC/D,eAAe,OAAO,iBAAyB,MAAM,MAAM,EAAE,QAAQ;EACrE,YAAY,OAAO,cAAsB,MAAM,MAAM,EAAE,QAAQ;EAC/D,WAAW,OAAO,aAAqB,MAAM,MAAM,EAAE,QAAQ;EAC7D,YAAY,OAAO,cAAsB,MAAM,MAAM,EAAE,QAAQ;EAChE;CACF,CAAC,CAEW"}

package/dist/exec.mjs

@@ -0,0 +1,26 @@
+import { t as loadRalphConfig } from "./loader.mjs";
+import { t as execInContainer } from "./lifecycle.mjs";
+import { defineCommand } from "citty";
+
+//#region src/commands/exec.ts
+var exec_default = defineCommand({
+	meta: {
+		name: "exec",
+		description: "Run arbitrary command inside container"
+	},
+	args: { command: {
+		type: "positional",
+		description: "Command to execute",
+		required: true
+	} },
+	async run({ args }) {
+		const config = await loadRalphConfig();
+		const rest = args._;
+		const command = [String(args.command), ...Array.isArray(rest) ? rest.map(String) : []];
+		await execInContainer(config.container.name, command);
+	}
+});
+
+//#endregion
+export { exec_default as default };
+//# sourceMappingURL=exec.mjs.map

package/dist/exec.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec.mjs","names":[],"sources":["../src/commands/exec.ts"],"sourcesContent":["import { defineCommand } from 'citty'\nimport { loadRalphConfig } from '../config/loader.js'\nimport { execInContainer } from '../container/lifecycle.js'\n\nexport default defineCommand({\n  meta: {\n    name: 'exec',\n    description: 'Run arbitrary command inside container',\n  },\n  args: {\n    command: {\n      type: 'positional',\n      description: 'Command to execute',\n      required: true,\n    },\n  },\n  async run({ args }) {\n    const config = await loadRalphConfig()\n    // args._ contains the rest of the arguments after the command\n    const rest = (args as Record<string, unknown>)._\n    const command = [String(args.command), ...(Array.isArray(rest) ? rest.map(String) : [])]\n    await execInContainer(config.container.name, command)\n  },\n})\n"],"mappings":";;;;;AAIA,mBAAe,cAAc;CAC3B,MAAM;EACJ,MAAM;EACN,aAAa;EACd;CACD,MAAM,EACJ,SAAS;EACP,MAAM;EACN,aAAa;EACb,UAAU;EACX,EACF;CACD,MAAM,IAAI,EAAE,QAAQ;EAClB,MAAM,SAAS,MAAM,iBAAiB;EAEtC,MAAM,OAAQ,KAAiC;EAC/C,MAAM,UAAU,CAAC,OAAO,KAAK,QAAQ,EAAE,GAAI,MAAM,QAAQ,KAAK,GAAG,KAAK,IAAI,OAAO,GAAG,EAAE,CAAE;AACxF,QAAM,gBAAgB,OAAO,UAAU,MAAM,QAAQ;;CAExD,CAAC"}

package/dist/generate.mjs

@@ -0,0 +1,34 @@
+import { t as loadRalphConfig } from "./loader.mjs";
+import { t as generateAll } from "./generators.mjs";
+import { defineCommand } from "citty";
+
+//#region src/commands/generate.ts
+var generate_default = defineCommand({
+	meta: {
+		name: "generate",
+		description: "Regenerate all files from config (idempotent)"
+	},
+	args: {
+		"dry-run": {
+			type: "boolean",
+			description: "Preview what would be generated",
+			default: false
+		},
+		only: {
+			type: "string",
+			description: "Only generate specific type: container|prompt|skills"
+		}
+	},
+	async run({ args }) {
+		const config = await loadRalphConfig();
+		const only = args.only;
+		await generateAll(config, process.cwd(), {
+			dryRun: args["dry-run"],
+			only
+		});
+	}
+});
+
+//#endregion
+export { generate_default as default };
+//# sourceMappingURL=generate.mjs.map

package/dist/generate.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.mjs","names":[],"sources":["../src/commands/generate.ts"],"sourcesContent":["import { defineCommand } from 'citty'\nimport { loadRalphConfig } from '../config/loader.js'\nimport { generateAll } from '../generators/index.js'\n\nexport default defineCommand({\n  meta: {\n    name: 'generate',\n    description: 'Regenerate all files from config (idempotent)',\n  },\n  args: {\n    'dry-run': {\n      type: 'boolean',\n      description: 'Preview what would be generated',\n      default: false,\n    },\n    only: {\n      type: 'string',\n      description: 'Only generate specific type: container|prompt|skills',\n    },\n  },\n  async run({ args }) {\n    const config = await loadRalphConfig()\n    const only = args.only as 'container' | 'prompt' | 'skills' | undefined\n    await generateAll(config, process.cwd(), {\n      dryRun: args['dry-run'],\n      only,\n    })\n  },\n})\n"],"mappings":";;;;;AAIA,uBAAe,cAAc;CAC3B,MAAM;EACJ,MAAM;EACN,aAAa;EACd;CACD,MAAM;EACJ,WAAW;GACT,MAAM;GACN,aAAa;GACb,SAAS;GACV;EACD,MAAM;GACJ,MAAM;GACN,aAAa;GACd;EACF;CACD,MAAM,IAAI,EAAE,QAAQ;EAClB,MAAM,SAAS,MAAM,iBAAiB;EACtC,MAAM,OAAO,KAAK;AAClB,QAAM,YAAY,QAAQ,QAAQ,KAAK,EAAE;GACvC,QAAQ,KAAK;GACb;GACD,CAAC;;CAEL,CAAC"}

package/dist/generators.mjs

@@ -0,0 +1,222 @@
+import { createRequire } from "node:module";
+import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { consola } from "consola";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import ejs from "ejs";
+import { tmpdir } from "node:os";
+import { generate, writeGeneratedFiles } from "universal-ai-config";
+
+//#region src/utils/template.ts
+/**
+* Resolve a bundled asset directory (templates, static, uac-templates).
+* In dist (flat layout): assets are siblings of the compiled files.
+* In src (nested layout via tsx): assets are siblings of the parent dir.
+*/
+function resolveAssetDir(assetName, metaUrl) {
+	const dir = dirname(fileURLToPath(metaUrl));
+	const sibling = join(dir, assetName);
+	if (existsSync(sibling)) return sibling;
+	return join(dir, "..", assetName);
+}
+const TEMPLATES_DIR = resolveAssetDir("templates", import.meta.url);
+async function renderTemplate(templateName, data) {
+	const template = await readFile(join(TEMPLATES_DIR, templateName), "utf8");
+	return ejs.render(template, data, { async: false });
+}
+const GENERATED_HEADER = `# Generated by fabis-ralph-loop — DO NOT EDIT MANUALLY
+# Regenerate with: npx fabis-ralph-loop generate
+`;
+
+//#endregion
+//#region src/utils/version.ts
+function getPackageVersion() {
+	try {
+		return createRequire(import.meta.url)("../../package.json").version;
+	} catch {
+		return "latest";
+	}
+}
+
+//#endregion
+//#region src/generators/dockerfile.ts
+/**
+* Detect whether the base image already includes Node.js.
+*/
+function isNodeBaseImage(baseImage) {
+	return /^node[:/]/i.test(baseImage);
+}
+async function generateDockerfile(config) {
+	const user = config.container.user;
+	return renderTemplate("Dockerfile.ejs", {
+		generatedHeader: GENERATED_HEADER,
+		baseImage: config.container.baseImage,
+		systemPackages: config.container.systemPackages,
+		installNode: !isNodeBaseImage(config.container.baseImage),
+		playwright: config.container.playwright,
+		hooks: config.container.hooks,
+		user,
+		createUser: user === "sandbox",
+		homeDir: `/home/${user}`,
+		packageVersion: getPackageVersion()
+	});
+}
+
+//#endregion
+//#region src/generators/compose.ts
+async function generateCompose(config) {
+	const homeDir = `/home/${config.container.user}`;
+	const persistVolumes = {
+		"ralph-claude-config": `${homeDir}/.claude`,
+		...Object.fromEntries(Object.entries(config.container.persistVolumes).map(([name, path]) => [name, path.replace("/home/sandbox", homeDir)]))
+	};
+	return renderTemplate("docker-compose.yml.ejs", {
+		generatedHeader: GENERATED_HEADER,
+		containerName: config.container.name,
+		shmSize: config.container.shmSize,
+		networkMode: config.container.networkMode,
+		capabilities: config.container.capabilities,
+		shadowVolumes: config.container.shadowVolumes,
+		persistVolumes,
+		extraVolumes: config.container.volumes,
+		env: config.container.env,
+		homeDir
+	});
+}
+
+//#endregion
+//#region src/generators/entrypoint.ts
+async function generateEntrypoint(config) {
+	const user = config.container.user;
+	return renderTemplate("entrypoint.ts.ejs", {
+		generatedHeader: GENERATED_HEADER.replace(/^# /gm, "// "),
+		agent: config.defaults.agent,
+		shadowVolumes: config.container.shadowVolumes,
+		entrypointSetup: config.container.hooks.entrypointSetup,
+		user,
+		homeDir: `/home/${user}`
+	});
+}
+
+//#endregion
+//#region src/generators/prompt.ts
+async function generatePrompt(config) {
+	return renderTemplate("ralph-prompt.md.ejs", {
+		generatedHeader: GENERATED_HEADER,
+		projectName: config.project.name,
+		projectDescription: config.project.description,
+		projectContext: config.project.context,
+		backpressureCommands: config.project.backpressureCommands,
+		openAppSkill: config.project.openAppSkill,
+		playwright: config.container.playwright,
+		completionSignal: config.defaults.completionSignal
+	});
+}
+
+//#endregion
+//#region src/generators/skills.ts
+const UAC_TEMPLATES_DIR = resolveAssetDir("uac-templates", import.meta.url);
+function buildLevel1Variables(config) {
+	return {
+		backpressureCommands: config.project.backpressureCommands,
+		projectName: config.project.name,
+		projectContext: config.project.context,
+		openAppSkill: config.project.openAppSkill,
+		playwright: config.container.playwright,
+		config
+	};
+}
+async function discoverSkills() {
+	return (await readdir(join(UAC_TEMPLATES_DIR, "skills"), { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+}
+async function generateSkills(config, projectRoot) {
+	if (config.output.mode === "direct") await generateDirect(config, projectRoot);
+	else await generateUac(config, projectRoot);
+}
+async function generateDirect(config, projectRoot) {
+	const variables = buildLevel1Variables(config);
+	const skills = await discoverSkills();
+	const tempDir = join(tmpdir(), `ralph-skills-${Date.now()}`);
+	try {
+		for (const skill of skills) {
+			const template = await readFile(join(UAC_TEMPLATES_DIR, "skills", skill, "SKILL.md"), "utf8");
+			const rendered = ejs.render(template, variables);
+			const outDir = join(tempDir, "skills", skill);
+			await mkdir(outDir, { recursive: true });
+			await writeFile(join(outDir, "SKILL.md"), rendered, "utf8");
+		}
+		const files = await generate({
+			root: projectRoot,
+			targets: ["claude"],
+			types: ["skills"],
+			overrides: { templatesDir: tempDir }
+		});
+		await writeGeneratedFiles(files, projectRoot);
+		consola.info(`Generated ${files.length} skill file(s)`);
+	} finally {
+		await rm(tempDir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+async function generateUac(config, projectRoot) {
+	const variables = buildLevel1Variables(config);
+	const skills = await discoverSkills();
+	let count = 0;
+	for (const skill of skills) {
+		const template = await readFile(join(UAC_TEMPLATES_DIR, "skills", skill, "SKILL.md"), "utf8");
+		const rendered = ejs.render(template, variables);
+		const outDir = join(projectRoot, config.output.uacTemplatesDir, "skills", skill);
+		await mkdir(outDir, { recursive: true });
+		await writeFile(join(outDir, "SKILL.md"), rendered, "utf8");
+		count++;
+	}
+	consola.info(`Generated ${count} skill template(s) to ${config.output.uacTemplatesDir}/skills/`);
+}
+
+//#endregion
+//#region src/generators/index.ts
+async function generateAll(config, projectRoot, options = {}) {
+	const files = [];
+	if (!options.only || options.only === "container") {
+		await mkdir(join(projectRoot, ".ralph-container"), { recursive: true });
+		const dockerfile = await generateDockerfile(config);
+		files.push({
+			path: join(".ralph-container", "Dockerfile"),
+			content: dockerfile
+		});
+		const entrypoint = await generateEntrypoint(config);
+		files.push({
+			path: join(".ralph-container", "entrypoint.ts"),
+			content: entrypoint
+		});
+		const compose = await generateCompose(config);
+		files.push({
+			path: join(".ralph-container", "docker-compose.yml"),
+			content: compose
+		});
+	}
+	if (!options.only || options.only === "prompt") {
+		const prompt = await generatePrompt(config);
+		files.push({
+			path: join(".ralph-container", "ralph-prompt.md"),
+			content: prompt
+		});
+	}
+	if (options.dryRun) for (const file of files) consola.info(`[dry-run] Would write: ${file.path}`);
+	else for (const file of files) {
+		const fullPath = join(projectRoot, file.path);
+		await mkdir(join(fullPath, ".."), { recursive: true });
+		await writeFile(fullPath, file.content, "utf8");
+		consola.success(`Written: ${file.path}`);
+	}
+	if (!options.only || options.only === "skills") if (options.dryRun) consola.info("[dry-run] Would generate skills");
+	else await generateSkills(config, projectRoot);
+	return files;
+}
+
+//#endregion
+export { generateAll as t };
+//# sourceMappingURL=generators.mjs.map

package/dist/generators.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"generators.mjs","names":[],"sources":["../src/utils/template.ts","../src/utils/version.ts","../src/generators/dockerfile.ts","../src/generators/compose.ts","../src/generators/entrypoint.ts","../src/generators/prompt.ts","../src/generators/skills.ts","../src/generators/index.ts"],"sourcesContent":["import { readFile } from 'node:fs/promises'\nimport { existsSync } from 'node:fs'\nimport { fileURLToPath } from 'node:url'\nimport { dirname, join } from 'node:path'\nimport ejs from 'ejs'\n\n/**\n * Resolve a bundled asset directory (templates, static, uac-templates).\n * In dist (flat layout): assets are siblings of the compiled files.\n * In src (nested layout via tsx): assets are siblings of the parent dir.\n */\nexport function resolveAssetDir(assetName: string, metaUrl: string): string {\n  const dir = dirname(fileURLToPath(metaUrl))\n  const sibling = join(dir, assetName)\n  if (existsSync(sibling)) return sibling\n  return join(dir, '..', assetName)\n}\n\nconst TEMPLATES_DIR = resolveAssetDir('templates', import.meta.url)\n\nexport async function renderTemplate(\n  templateName: string,\n  data: Record<string, unknown>,\n): Promise<string> {\n  const templatePath = join(TEMPLATES_DIR, templateName)\n  const template = await readFile(templatePath, 'utf8')\n  return ejs.render(template, data, { async: false }) as string\n}\n\nexport const GENERATED_HEADER = `# Generated by fabis-ralph-loop — DO NOT EDIT MANUALLY\n# Regenerate with: npx fabis-ralph-loop generate\n`\n","import { createRequire } from 'node:module'\n\nexport function getPackageVersion(): string {\n  try {\n    const require = createRequire(import.meta.url)\n    const pkg = require('../../package.json') as { version: string }\n    return pkg.version\n  } catch {\n    return 'latest'\n  }\n}\n","import { renderTemplate, GENERATED_HEADER } from '../utils/template.js'\nimport { getPackageVersion } from '../utils/version.js'\nimport type { ResolvedConfig } from '../config/schema.js'\n\n/**\n * Detect whether the base image already includes Node.js.\n */\nfunction isNodeBaseImage(baseImage: string): boolean {\n  return /^node[:/]/i.test(baseImage)\n}\n\nexport async function generateDockerfile(config: ResolvedConfig): Promise<string> {\n  const user = config.container.user\n  return renderTemplate('Dockerfile.ejs', {\n    generatedHeader: GENERATED_HEADER,\n    baseImage: config.container.baseImage,\n    systemPackages: config.container.systemPackages,\n    installNode: !isNodeBaseImage(config.container.baseImage),\n    playwright: config.container.playwright,\n    hooks: config.container.hooks,\n    user,\n    createUser: user === 'sandbox',\n    homeDir: `/home/${user}`,\n    packageVersion: getPackageVersion(),\n  })\n}\n","import { renderTemplate, GENERATED_HEADER } from '../utils/template.js'\nimport type { ResolvedConfig } from '../config/schema.js'\n\nexport async function generateCompose(config: ResolvedConfig): Promise<string> {\n  const homeDir = `/home/${config.container.user}`\n\n  // Ensure .claude config is always persisted with the correct home dir\n  const persistVolumes: Record<string, string> = {\n    'ralph-claude-config': `${homeDir}/.claude`,\n    ...Object.fromEntries(\n      Object.entries(config.container.persistVolumes).map(([name, path]) => [\n        name,\n        path.replace('/home/sandbox', homeDir),\n      ]),\n    ),\n  }\n\n  return renderTemplate('docker-compose.yml.ejs', {\n    generatedHeader: GENERATED_HEADER,\n    containerName: config.container.name,\n    shmSize: config.container.shmSize,\n    networkMode: config.container.networkMode,\n    capabilities: config.container.capabilities,\n    shadowVolumes: config.container.shadowVolumes,\n    persistVolumes,\n    extraVolumes: config.container.volumes,\n    env: config.container.env,\n    homeDir,\n  })\n}\n","import { renderTemplate, GENERATED_HEADER } from '../utils/template.js'\nimport type { ResolvedConfig } from '../config/schema.js'\n\nexport async function generateEntrypoint(config: ResolvedConfig): Promise<string> {\n  const user = config.container.user\n  return renderTemplate('entrypoint.ts.ejs', {\n    generatedHeader: GENERATED_HEADER.replace(/^# /gm, '// '),\n    agent: config.defaults.agent,\n    shadowVolumes: config.container.shadowVolumes,\n    entrypointSetup: config.container.hooks.entrypointSetup,\n    user,\n    homeDir: `/home/${user}`,\n  })\n}\n","import { renderTemplate, GENERATED_HEADER } from '../utils/template.js'\nimport type { ResolvedConfig } from '../config/schema.js'\n\nexport async function generatePrompt(config: ResolvedConfig): Promise<string> {\n  return renderTemplate('ralph-prompt.md.ejs', {\n    generatedHeader: GENERATED_HEADER,\n    projectName: config.project.name,\n    projectDescription: config.project.description,\n    projectContext: config.project.context,\n    backpressureCommands: config.project.backpressureCommands,\n    openAppSkill: config.project.openAppSkill,\n    playwright: config.container.playwright,\n    completionSignal: config.defaults.completionSignal,\n  })\n}\n","import { readdir, readFile, writeFile, mkdir, rm } from 'node:fs/promises'\nimport { join } from 'node:path'\nimport { tmpdir } from 'node:os'\nimport ejs from 'ejs'\nimport { consola } from 'consola'\nimport { generate, writeGeneratedFiles } from 'universal-ai-config'\nimport type { ResolvedConfig } from '../config/schema.js'\nimport { resolveAssetDir } from '../utils/template.js'\n\nconst UAC_TEMPLATES_DIR = resolveAssetDir('uac-templates', import.meta.url)\n\nfunction buildLevel1Variables(config: ResolvedConfig): Record<string, unknown> {\n  return {\n    backpressureCommands: config.project.backpressureCommands,\n    projectName: config.project.name,\n    projectContext: config.project.context,\n    openAppSkill: config.project.openAppSkill,\n    playwright: config.container.playwright,\n    config,\n  }\n}\n\nasync function discoverSkills(): Promise<string[]> {\n  const skillsDir = join(UAC_TEMPLATES_DIR, 'skills')\n  const entries = await readdir(skillsDir, { withFileTypes: true })\n  return entries.filter((e) => e.isDirectory()).map((e) => e.name)\n}\n\nexport async function generateSkills(config: ResolvedConfig, projectRoot: string): Promise<void> {\n  if (config.output.mode === 'direct') {\n    await generateDirect(config, projectRoot)\n  } else {\n    await generateUac(config, projectRoot)\n  }\n}\n\nasync function generateDirect(config: ResolvedConfig, projectRoot: string): Promise<void> {\n  const variables = buildLevel1Variables(config)\n  const skills = await discoverSkills()\n\n  // Render Level 1 EJS and write to a temp dir structured as UAC templates\n  const tempDir = join(tmpdir(), `ralph-skills-${Date.now()}`)\n\n  try {\n    for (const skill of skills) {\n      const templatePath = join(UAC_TEMPLATES_DIR, 'skills', skill, 'SKILL.md')\n      const template = await readFile(templatePath, 'utf8')\n      const rendered = ejs.render(template, variables) as string\n\n      const outDir = join(tempDir, 'skills', skill)\n      await mkdir(outDir, { recursive: true })\n      await writeFile(join(outDir, 'SKILL.md'), rendered, 'utf8')\n    }\n\n    // Use UAC's generate() API for the second pass (handles Level 2 EJS + frontmatter mapping)\n    const files = await generate({\n      root: projectRoot,\n      targets: ['claude'],\n      types: ['skills'],\n      overrides: { templatesDir: tempDir },\n    })\n\n    await writeGeneratedFiles(files, projectRoot)\n    consola.info(`Generated ${files.length} skill file(s)`)\n  } finally {\n    await rm(tempDir, { recursive: true, force: true })\n  }\n}\n\nasync function generateUac(config: ResolvedConfig, projectRoot: string): Promise<void> {\n  const variables = buildLevel1Variables(config)\n  const skills = await discoverSkills()\n  let count = 0\n\n  for (const skill of skills) {\n    const templatePath = join(UAC_TEMPLATES_DIR, 'skills', skill, 'SKILL.md')\n    const template = await readFile(templatePath, 'utf8')\n    // Render Level 1 EJS — Level 2 <%% %> becomes <% %> in output\n    const rendered = ejs.render(template, variables) as string\n\n    const outDir = join(projectRoot, config.output.uacTemplatesDir, 'skills', skill)\n    await mkdir(outDir, { recursive: true })\n    await writeFile(join(outDir, 'SKILL.md'), rendered, 'utf8')\n    count++\n  }\n\n  consola.info(`Generated ${count} skill template(s) to ${config.output.uacTemplatesDir}/skills/`)\n}\n","import { mkdir, writeFile } from 'node:fs/promises'\nimport { join } from 'node:path'\nimport { consola } from 'consola'\nimport { generateDockerfile } from './dockerfile.js'\nimport { generateCompose } from './compose.js'\nimport { generateEntrypoint } from './entrypoint.js'\nimport { generatePrompt } from './prompt.js'\nimport { generateSkills } from './skills.js'\nimport type { ResolvedConfig } from '../config/schema.js'\n\ninterface GenerateOptions {\n  dryRun?: boolean\n  only?: 'container' | 'prompt' | 'skills'\n}\n\ninterface GeneratedFile {\n  path: string\n  content: string\n}\n\nexport async function generateAll(\n  config: ResolvedConfig,\n  projectRoot: string,\n  options: GenerateOptions = {},\n): Promise<GeneratedFile[]> {\n  const files: GeneratedFile[] = []\n\n  if (!options.only || options.only === 'container') {\n    const containerDir = join(projectRoot, '.ralph-container')\n    await mkdir(containerDir, { recursive: true })\n\n    const dockerfile = await generateDockerfile(config)\n    files.push({ path: join('.ralph-container', 'Dockerfile'), content: dockerfile })\n\n    const entrypoint = await generateEntrypoint(config)\n    files.push({ path: join('.ralph-container', 'entrypoint.ts'), content: entrypoint })\n\n    const compose = await generateCompose(config)\n    files.push({ path: join('.ralph-container', 'docker-compose.yml'), content: compose })\n  }\n\n  if (!options.only || options.only === 'prompt') {\n    const prompt = await generatePrompt(config)\n    files.push({ path: join('.ralph-container', 'ralph-prompt.md'), content: prompt })\n  }\n\n  if (options.dryRun) {\n    for (const file of files) {\n      consola.info(`[dry-run] Would write: ${file.path}`)\n    }\n  } else {\n    for (const file of files) {\n      const fullPath = join(projectRoot, file.path)\n      await mkdir(join(fullPath, '..'), { recursive: true })\n      await writeFile(fullPath, file.content, 'utf8')\n      consola.success(`Written: ${file.path}`)\n    }\n  }\n\n  if (!options.only || options.only === 'skills') {\n    if (options.dryRun) {\n      consola.info('[dry-run] Would generate skills')\n    } else {\n      await generateSkills(config, projectRoot)\n    }\n  }\n\n  return files\n}\n"],"mappings":"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"}

package/dist/index.d.mts

@@ -0,0 +1,125 @@
+import { z } from "zod";
+
+//#region src/config/schema.d.ts
+declare const backpressureCommandSchema: z.ZodObject<{
+  name: z.ZodString;
+  command: z.ZodString;
+}, z.core.$strip>;
+declare const ralphLoopConfigSchema: z.ZodObject<{
+  container: z.ZodPrefault<z.ZodObject<{
+    name: z.ZodString;
+    baseImage: z.ZodDefault<z.ZodString>;
+    user: z.ZodDefault<z.ZodString>;
+    systemPackages: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    playwright: z.ZodDefault<z.ZodBoolean>;
+    networkMode: z.ZodDefault<z.ZodString>;
+    env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    shmSize: z.ZodDefault<z.ZodString>;
+    capabilities: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    volumes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    shadowVolumes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    persistVolumes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    hooks: z.ZodPrefault<z.ZodObject<{
+      rootSetup: z.ZodDefault<z.ZodArray<z.ZodString>>;
+      userSetup: z.ZodDefault<z.ZodArray<z.ZodString>>;
+      entrypointSetup: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  setup: z.ZodPrefault<z.ZodObject<{
+    preStartCommand: z.ZodDefault<z.ZodString>;
+  }, z.core.$strip>>;
+  defaults: z.ZodPrefault<z.ZodObject<{
+    agent: z.ZodDefault<z.ZodLiteral<"claude">>;
+    model: z.ZodDefault<z.ZodString>;
+    verbose: z.ZodDefault<z.ZodBoolean>;
+    sleepBetweenMs: z.ZodDefault<z.ZodNumber>;
+    completionSignal: z.ZodDefault<z.ZodString>;
+  }, z.core.$strip>>;
+  project: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodDefault<z.ZodString>;
+    context: z.ZodDefault<z.ZodString>;
+    backpressureCommands: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      command: z.ZodString;
+    }, z.core.$strip>>>;
+    openAppSkill: z.ZodDefault<z.ZodString>;
+  }, z.core.$strip>;
+  output: z.ZodPrefault<z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+      direct: "direct";
+      uac: "uac";
+    }>>;
+    uacTemplatesDir: z.ZodDefault<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type RalphLoopConfig = z.input<typeof ralphLoopConfigSchema>;
+type ResolvedConfig = z.output<typeof ralphLoopConfigSchema>;
+type BackpressureCommand = z.infer<typeof backpressureCommandSchema>;
+//#endregion
+//#region src/config/loader.d.ts
+declare function loadRalphConfig(cwd?: string): Promise<ResolvedConfig>;
+//#endregion
+//#region src/generators/index.d.ts
+interface GenerateOptions {
+  dryRun?: boolean;
+  only?: 'container' | 'prompt' | 'skills';
+}
+interface GeneratedFile {
+  path: string;
+  content: string;
+}
+declare function generateAll(config: ResolvedConfig, projectRoot: string, options?: GenerateOptions): Promise<GeneratedFile[]>;
+//#endregion
+//#region src/index.d.ts
+/**
+ * Helper for defining a typed ralph-loop config.
+ */
+declare function defineConfig(config: RalphLoopConfig): {
+  project: {
+    name: string;
+    description?: string | undefined;
+    context?: string | undefined;
+    backpressureCommands?: {
+      name: string;
+      command: string;
+    }[] | undefined;
+    openAppSkill?: string | undefined;
+  };
+  container?: {
+    name: string;
+    baseImage?: string | undefined;
+    user?: string | undefined;
+    systemPackages?: string[] | undefined;
+    playwright?: boolean | undefined;
+    networkMode?: string | undefined;
+    env?: Record<string, string> | undefined;
+    shmSize?: string | undefined;
+    capabilities?: string[] | undefined;
+    volumes?: string[] | undefined;
+    shadowVolumes?: string[] | undefined;
+    persistVolumes?: Record<string, string> | undefined;
+    hooks?: {
+      rootSetup?: string[] | undefined;
+      userSetup?: string[] | undefined;
+      entrypointSetup?: string[] | undefined;
+    } | undefined;
+  } | undefined;
+  setup?: {
+    preStartCommand?: string | undefined;
+  } | undefined;
+  defaults?: {
+    agent?: "claude" | undefined;
+    model?: string | undefined;
+    verbose?: boolean | undefined;
+    sleepBetweenMs?: number | undefined;
+    completionSignal?: string | undefined;
+  } | undefined;
+  output?: {
+    mode?: "direct" | "uac" | undefined;
+    uacTemplatesDir?: string | undefined;
+  } | undefined;
+};
+//#endregion
+export { type BackpressureCommand, type RalphLoopConfig, type ResolvedConfig, defineConfig, generateAll, loadRalphConfig, ralphLoopConfigSchema };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/config/schema.ts","../src/config/loader.ts","../src/generators/index.ts","../src/index.ts"],"mappings":";;;cAEM,yBAAA,EAAyB,CAAA,CAAA,SAAA;;;;cAsDlB,qBAAA,EAAqB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAQtB,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,qBAAA;AAAA,KACjC,cAAA,GAAiB,CAAA,CAAE,MAAA,QAAc,qBAAA;AAAA,KACjC,mBAAA,GAAsB,CAAA,CAAE,KAAA,QAAa,yBAAA;;;iBC7D3B,eAAA,CAAgB,GAAA,YAAe,OAAA,CAAQ,cAAA;;;UCKnD,eAAA;EACR,MAAA;EACA,IAAA;AAAA;AAAA,UAGQ,aAAA;EACR,IAAA;EACA,OAAA;AAAA;AAAA,iBAGoB,WAAA,CACpB,MAAA,EAAQ,cAAA,EACR,WAAA,UACA,OAAA,GAAS,eAAA,GACR,OAAA,CAAQ,aAAA;;;;;;iBChBK,YAAA,CAAa,MAAA,EAAD,eAAA"}

package/dist/index.mjs

@@ -0,0 +1,14 @@
+import { n as ralphLoopConfigSchema, t as loadRalphConfig } from "./loader.mjs";
+import { t as generateAll } from "./generators.mjs";
+
+//#region src/index.ts
+/**
+* Helper for defining a typed ralph-loop config.
+*/
+function defineConfig(config) {
+	return config;
+}
+
+//#endregion
+export { defineConfig, generateAll, loadRalphConfig, ralphLoopConfigSchema };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["export { ralphLoopConfigSchema } from './config/schema.js'\nexport type { RalphLoopConfig, ResolvedConfig, BackpressureCommand } from './config/schema.js'\nexport { loadRalphConfig } from './config/loader.js'\nexport { generateAll } from './generators/index.js'\n\n/**\n * Helper for defining a typed ralph-loop config.\n */\nexport function defineConfig(config: import('./config/schema.js').RalphLoopConfig) {\n  return config\n}\n"],"mappings":";;;;;;;AAQA,SAAgB,aAAa,QAAsD;AACjF,QAAO"}

package/dist/init.mjs

@@ -0,0 +1,55 @@
+import { t as loadRalphConfig } from "./loader.mjs";
+import { t as generateAll } from "./generators.mjs";
+import { writeFile } from "node:fs/promises";
+import { consola } from "consola";
+import { existsSync } from "node:fs";
+import { defineCommand } from "citty";
+
+//#region src/commands/init.ts
+const SAMPLE_CONFIG = `import { defineConfig } from 'fabis-ralph-loop'
+
+export default defineConfig({
+  container: {
+    name: 'my-ralph-container',
+    baseImage: 'node:22-bookworm',
+    // playwright: true,
+    // shadowVolumes: ['/workspace/node_modules'],
+    hooks: {
+      rootSetup: [
+        // 'RUN npm install -g pnpm@10',
+      ],
+      userSetup: [
+        // 'RUN corepack enable',
+      ],
+    },
+  },
+  project: {
+    name: 'My Project',
+    description: '',
+    context: '- **Monorepo** managed with npm\\n- **TypeScript strict mode** everywhere',
+  },
+  output: {
+    mode: 'direct',
+  },
+})
+`;
+var init_default = defineCommand({
+	meta: {
+		name: "init",
+		description: "Scaffold ralph-loop config and generate all files"
+	},
+	async run() {
+		const configPath = "fabis-ralph-loop.config.ts";
+		if (existsSync(configPath)) consola.warn(`${configPath} already exists. Regenerating files from existing config.`);
+		else {
+			await writeFile(configPath, SAMPLE_CONFIG, "utf8");
+			consola.success(`Created ${configPath}`);
+		}
+		await generateAll(await loadRalphConfig(), process.cwd());
+		consola.success("Init complete. Edit fabis-ralph-loop.config.ts and run `fabis-ralph-loop generate` to regenerate.");
+	}
+});
+
+//#endregion
+export { init_default as default };
+//# sourceMappingURL=init.mjs.map

package/dist/init.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.mjs","names":[],"sources":["../src/commands/init.ts"],"sourcesContent":["import { defineCommand } from 'citty'\nimport { writeFile } from 'node:fs/promises'\nimport { existsSync } from 'node:fs'\nimport { consola } from 'consola'\nimport { loadRalphConfig } from '../config/loader.js'\nimport { generateAll } from '../generators/index.js'\n\nconst SAMPLE_CONFIG = `import { defineConfig } from 'fabis-ralph-loop'\n\nexport default defineConfig({\n  container: {\n    name: 'my-ralph-container',\n    baseImage: 'node:22-bookworm',\n    // playwright: true,\n    // shadowVolumes: ['/workspace/node_modules'],\n    hooks: {\n      rootSetup: [\n        // 'RUN npm install -g pnpm@10',\n      ],\n      userSetup: [\n        // 'RUN corepack enable',\n      ],\n    },\n  },\n  project: {\n    name: 'My Project',\n    description: '',\n    context: '- **Monorepo** managed with npm\\\\n- **TypeScript strict mode** everywhere',\n  },\n  output: {\n    mode: 'direct',\n  },\n})\n`\n\nexport default defineCommand({\n  meta: {\n    name: 'init',\n    description: 'Scaffold ralph-loop config and generate all files',\n  },\n  async run() {\n    const configPath = 'fabis-ralph-loop.config.ts'\n\n    if (existsSync(configPath)) {\n      consola.warn(`${configPath} already exists. Regenerating files from existing config.`)\n    } else {\n      await writeFile(configPath, SAMPLE_CONFIG, 'utf8')\n      consola.success(`Created ${configPath}`)\n    }\n\n    // Load config and generate\n    const config = await loadRalphConfig()\n    await generateAll(config, process.cwd())\n\n    consola.success(\n      'Init complete. Edit fabis-ralph-loop.config.ts and run `fabis-ralph-loop generate` to regenerate.',\n    )\n  },\n})\n"],"mappings":";;;;;;;;AAOA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BtB,mBAAe,cAAc;CAC3B,MAAM;EACJ,MAAM;EACN,aAAa;EACd;CACD,MAAM,MAAM;EACV,MAAM,aAAa;AAEnB,MAAI,WAAW,WAAW,CACxB,SAAQ,KAAK,GAAG,WAAW,2DAA2D;OACjF;AACL,SAAM,UAAU,YAAY,eAAe,OAAO;AAClD,WAAQ,QAAQ,WAAW,aAAa;;AAK1C,QAAM,YADS,MAAM,iBAAiB,EACZ,QAAQ,KAAK,CAAC;AAExC,UAAQ,QACN,oGACD;;CAEJ,CAAC"}