tunestra 0.1.0 → 0.2.0

package/README.md

@@ -9,8 +9,8 @@
 > Tune your AI agents to play as one orchestra.
 
 > [!WARNING]
-> **Early version.** v0.1 supports Claude Code; Codex comes in v0.2. The formats may still
-> change before v1.0.
+> **Early version.** tunestra supports Claude Code and Codex. The formats may still change
+> before v1.0.
 
 tunestra gives Claude Code, Codex and other AI coding agents **one shared source** of rules,
 skills, commands and MCP servers, and generates each agent's native configuration from it.
@@ -33,7 +33,7 @@ specific one wins.
 
 ```sh
 npx tunestra init --extends github:<organisation_name>/<presets_repo>/team#v1
-npx tunestra setup    # generates AGENTS.md, CLAUDE.md, .claude/, .agents/, .mcp.json
+npx tunestra setup    # generates AGENTS.md and the configuration of every agent
 ```
 
 `init` creates `tunestra.yaml`:
@@ -41,7 +41,7 @@ npx tunestra setup    # generates AGENTS.md, CLAUDE.md, .claude/, .agents/, .mcp
 ```yaml
 extends:
   - github:<organisation_name>/<presets_repo>/team#v1
-agents: [claude]
+agents: [claude]            # add codex: [claude, codex]
 ```
 
 Commit `tunestra.yaml`, `.tunestra/`, `AGENTS.md` and `CLAUDE.md`. Everything else that
@@ -97,7 +97,7 @@ as a preset.
 name: my-service            # optional, defaults to the directory name
 extends:
   - ../presets/team
-agents: [claude]            # v0.1 supports claude
+agents: [claude, codex]     # claude, codex; defaults to [claude]
 exclude: {}
 overrides: {}
 ```
@@ -116,7 +116,7 @@ repository with a relative path, like `../base`. A relative path cannot leave th
 Git is not needed: repositories are downloaded as archives over HTTPS.
 
 For a private repository, set the `TUNESTRA_GIT_TOKEN` environment variable to a token with
-read access. Lockfiles and npm sources are planned for v0.3.
+read access. Lockfiles and npm sources are planned for v0.4.
 
 ## Inheritance
 
@@ -153,20 +153,42 @@ are merged by key (the specific value wins); `command`, `args` and `url` are rep
 
 All problems are reported at once, in the order of the files, so you can fix them in one pass.
 
-## What gets generated (Claude Code)
+## What gets generated
+
+For every agent:
 
 | Path | Content | Committed |
 |---|---|---|
 | `AGENTS.md` | Index: hierarchy, rules, skills, commands, MCP servers | yes |
-| `CLAUDE.md` | `@AGENTS.md` | yes |
 | `.agents/rules/<NN>-<level>-<key>.md` | Rule texts, ordered from specific to general | no |
 | `.agents/skills/<key>/` | Skills | no |
+| `.tunestra/state/` | What tunestra generated last time | no |
+| `.gitignore` | A block between `# >>> tunestra` and `# <<< tunestra` | yes |
+
+### Claude Code
+
+| Path | Content | Committed |
+|---|---|---|
+| `CLAUDE.md` | `@AGENTS.md` | yes |
 | `.claude/rules/tunestra/<NN>-<level>-<key>.md` | Copies of the rules; Claude Code loads them in every session | no |
 | `.claude/skills/<key>` | Symlinks to `.agents/skills/<key>` | no |
 | `.claude/commands/<key>.md` | Commands | no |
 | `.mcp.json` | MCP servers | no |
-| `.tunestra/state/` | What tunestra generated last time | no |
-| `.gitignore` | A block between `# >>> tunestra` and `# <<< tunestra` | yes |
+
+### Codex
+
+Codex reads `AGENTS.md` and `.agents/skills/` by itself. It does not follow the links in
+`AGENTS.md`, so tunestra gives it the rule texts in its config.
+
+| Path | Content | Committed |
+|---|---|---|
+| `.codex/config.toml` | `developer_instructions` with every rule, from specific to general, and `[mcp_servers]` | no |
+| `.agents/skills/<command>/` | Each command as a skill that runs only when you call it: `$release-notes` | no |
+
+Codex reads `.codex/config.toml` only in a trusted project: trust the project when Codex asks.
+Codex has no `type` for MCP servers and does not support SSE: an SSE server is skipped with a
+note, and `headers` become `http_headers`. tunestra owns the whole `.codex/config.toml`; keep
+your personal Codex settings in `~/.codex/config.toml`.
 
 `<NN>` orders rules from specific to general: `10` project, `20` team, `30` domain, `40` base.
 Level instructions get the key `instructions`, and the preset name when it differs from the
@@ -180,7 +202,9 @@ Every generated rule starts with its origin:
 > Level: team, preset: team. Overrides: base.
 ```
 
-Skills and commands are copied as is: their frontmatter must stay on the first line.
+Skills and commands are copied as is: their frontmatter must stay on the first line. For
+Codex, a command gets only `name` and `description` in its frontmatter; other fields, like
+`argument-hint`, are for Claude Code.
 
 ## Running setup again
 
@@ -214,14 +238,15 @@ and tells you where to move their text.
 
 | Release | Scope |
 |---|---|
-| v0.1 | Inheritance for Claude Code (this document) |
-| v0.2 | Codex |
-| v0.3 | Spaces, npm sources, lockfile |
-| v0.4 | `required` / `locked` policies, CI check |
-| v0.5 | Hooks |
-| v0.6 | LLM gateway, permissions |
-| v0.7 | Local plugins |
-| v0.8 | Isolated remote plugins |
+| v0.1 | Inheritance for Claude Code |
+| v0.2 | Codex (this document) |
+| v0.3 | Subagents, a personal `local` level, `env` and permissions |
+| v0.4 | Spaces, npm sources, lockfile |
+| v0.5 | `required` / `locked` policies, CI check |
+| v0.6 | Hooks |
+| v0.7 | LLM gateway |
+| v0.8 | Local plugins |
+| v0.9 | Isolated remote plugins |
 
 ## License
 

package/dist/cli.mjs

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
-import { t as VERSION } from "./src-DSbrKtiC.mjs";
+import { t as VERSION } from "./src-jfoAZbqo.mjs";
 import { Command } from "@commander-js/extra-typings";
 import pc from "picocolors";
 import { copyFile, lstat, mkdir, readFile, readdir, readlink, rename, rm, rmdir, stat, symlink, unlink, writeFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
 import { glob } from "tinyglobby";
 import { prettifyError, z } from "zod";
-import { parse } from "yaml";
+import { parse, stringify } from "yaml";
 import { downloadTemplate } from "giget";
+import { stringify as stringify$1 } from "smol-toml";
 import { createHash } from "node:crypto";
 //#region src/shared/constants/files.ts
 /** Preset manifest, in the root of every preset. */
@@ -32,6 +33,11 @@ const OutputKind = {
 /** First line of every generated markdown file; tunestra recognizes its files by it. */
 const GENERATED_MARKER = "<!-- Generated by tunestra";
 const GENERATED_NOTICE = `${GENERATED_MARKER}. Do not edit: change the sources and run \`tunestra setup\`. -->`;
+/** The same marker for generated TOML and YAML files, where a comment starts with `#`. */
+const GENERATED_HASH_MARKER = "# Generated by tunestra";
+const GENERATED_HASH_NOTICE = `${GENERATED_HASH_MARKER}. Do not edit: change the sources and run \`tunestra setup\`.`;
+/** Every marker that tunestra puts on the first line of a generated file. */
+const GENERATED_MARKERS = [GENERATED_MARKER, GENERATED_HASH_MARKER];
 /** Shared output that any agent can read. */
 const AGENTS_DIR = ".agents";
 /** Rules for every agent, ordered from specific to general by their file names. */
@@ -143,10 +149,22 @@ async function readFileIfExists(path) {
 		throw error;
 	}
 }
+/** Removes a directory only when it has nothing inside; a missing directory is fine too. */
+async function removeDirIfEmpty(dir) {
+	try {
+		if ((await readdir(dir)).length === 0) await rmdir(dir);
+	} catch (error) {
+		if (isMissingPathError(error)) return;
+		throw error;
+	}
+}
 //#endregion
 //#region src/shared/constants/agents.ts
 /** Agents that tunestra generates configuration for. */
-const Agent = { Claude: "claude" };
+const Agent = {
+	Claude: "claude",
+	Codex: "codex"
+};
 //#endregion
 //#region src/init/render-config.ts
 const EXTENDS_EXAMPLE = "#   - github:<owner>/<repo>/<path>#<ref>";
@@ -437,13 +455,14 @@ async function loadCommands(dir) {
 async function loadCommand(dir, source) {
 	const file = join(dir, source);
 	const content = await readFile(file, "utf8");
-	const { data } = parseFrontmatter(content, file);
+	const { data, body } = parseFrontmatter(content, file);
 	const frontmatter = validate(data, commandFrontmatterSchema, `frontmatter in ${file}`);
 	return {
 		key: basename(source, ".md"),
 		source,
 		description: frontmatter.description,
-		content
+		content,
+		body
 	};
 }
 //#endregion
@@ -932,7 +951,8 @@ function planClaude(context) {
 			`${COMMANDS_DIR}/`,
 			MCP_FILE
 		],
-		protectedPaths: [CLAUDE_FILE]
+		protectedPaths: [CLAUDE_FILE],
+		notes: []
 	};
 }
 function copyRule(ruleFile) {
@@ -952,9 +972,147 @@ function linkSkill(projectDir, skill) {
 	};
 }
 //#endregion
+//#region src/agents/codex/command-skill.ts
+/** Codex starts the skill only when people call it, like a command. */
+const OPENAI_YAML = [
+	GENERATED_HASH_NOTICE,
+	"policy:",
+	"  allow_implicit_invocation: false",
+	""
+].join("\n");
+/**
+* Codex has no project commands, so a command becomes a skill with the same name that runs
+* only on `$<name>`. The skill gets `name` and `description`; other frontmatter of the
+* command belongs to Claude Code.
+*/
+function planCommandSkill(projectDir, command) {
+	const { key, description, body } = command.artifact;
+	const dir = `${AGENTS_SKILLS_DIR}/${key}`;
+	const source = describeArtifactSource(projectDir, command.origin, command.artifact.source);
+	const frontmatter = {
+		name: key,
+		description: description ?? `The /${key} command`
+	};
+	const skill = `---\n${stringify(frontmatter)}---\n${body}`;
+	const skillPath = `${dir}/SKILL.md`;
+	const policyPath = `${dir}/agents/openai.yaml`;
+	return [createFileOutput(skillPath, skill, source), createFileOutput(policyPath, OPENAI_YAML, source)];
+}
+//#endregion
+//#region src/agents/codex/config-toml.ts
+/** Starts and ends a multi-line literal string, where TOML escapes nothing. */
+const LITERAL_DELIMITER = "'''";
+/**
+* Control characters that a TOML literal string cannot hold. Tab and line feed are allowed;
+* a carriage return is in the list, because only `\r\n` would be valid.
+*
+* Matches:        "\u0000", "\r", "\u001B" (escape), "\u007F" (delete)
+* Does not match: "\t", "\n", "é", "→"
+*/
+const CONTROL_CHARACTER_PATTERN = /[\u0000-\u0008\u000B-\u001F\u007F]/;
+/**
+* `.codex/config.toml`: the rules as `developer_instructions`, which Codex adds to every
+* session, and the MCP servers. The rules are a literal string, so that people can read them.
+*/
+function renderConfigToml(instructions, servers) {
+	const parts = [GENERATED_HASH_NOTICE];
+	if (typeof instructions === "string") {
+		const line = renderInstructions$1(instructions);
+		parts.push(line);
+	}
+	if (servers.length > 0) {
+		const entries = servers.map((server) => {
+			const config = convertMcpConfig(server.artifact.config);
+			return [server.artifact.key, config];
+		});
+		const content = { mcp_servers: Object.fromEntries(entries) };
+		const tables = stringify$1(content).trimEnd();
+		parts.push(tables);
+	}
+	return `${parts.join("\n\n")}\n`;
+}
+function renderInstructions$1(text) {
+	const hasDelimiter = text.includes(LITERAL_DELIMITER);
+	const hasControlCharacter = CONTROL_CHARACTER_PATTERN.test(text);
+	if (hasDelimiter || hasControlCharacter) return stringify$1({ developer_instructions: text });
+	return `developer_instructions = ${LITERAL_DELIMITER}\n${text}${LITERAL_DELIMITER}`;
+}
+/** Codex picks the transport by `command` or `url` and has no `type`. */
+function convertMcpConfig(config) {
+	const { type: _type, headers, ...server } = config;
+	if (headers === void 0) return server;
+	return {
+		...server,
+		http_headers: headers
+	};
+}
+//#endregion
+//#region src/agents/codex/codex-adapter.ts
+const CONFIG_FILE = ".codex/config.toml";
+const CONFIG_SOURCE = "the rules/ and mcp/ folders of tunestra.yaml and its presets";
+const INSTRUCTIONS_INTRO = "Rules of this project, ordered from specific to general. When two rules conflict, follow the one that comes first.";
+const TRUST_NOTE = "Codex reads rules and MCP servers from .codex/config.toml only in a trusted project: trust the project when Codex asks.";
+/**
+* Codex reads AGENTS.md and the skills in `.agents/skills` by itself. Rules go to
+* `developer_instructions` in `.codex/config.toml`, because Codex does not follow the links
+* in AGENTS.md; MCP servers go to the same file. Commands become skills.
+*/
+const codexAdapter = {
+	agent: Agent.Codex,
+	plan: planCodex
+};
+function planCodex(context) {
+	const { resolution, ruleFiles } = context;
+	const projectDir = resolution.chain.project.dir;
+	const notes = [];
+	const outputs = [];
+	const commandSkills = resolution.commands.filter((command) => {
+		if (skillName.safeParse(command.artifact.key).success) return true;
+		notes.push(`Codex skips the command "${command.artifact.key}": a skill name needs lowercase letters, digits and single hyphens.`);
+		return false;
+	}).flatMap((command) => planCommandSkill(projectDir, command));
+	outputs.push(...commandSkills);
+	const configFile = planConfigFile(ruleFiles, resolution.mcp.filter((server) => {
+		if (server.artifact.config.type === "sse") {
+			notes.push(`Codex skips the MCP server "${server.artifact.key}": Codex does not support SSE.`);
+			return false;
+		}
+		return true;
+	}));
+	if (configFile === void 0) return {
+		outputs,
+		ignoredPaths: [],
+		protectedPaths: [],
+		notes
+	};
+	outputs.push(configFile);
+	notes.push(TRUST_NOTE);
+	return {
+		outputs,
+		ignoredPaths: [CONFIG_FILE],
+		protectedPaths: [],
+		notes
+	};
+}
+function planConfigFile(ruleFiles, servers) {
+	const hasRules = ruleFiles.length > 0;
+	const hasServers = servers.length > 0;
+	if (hasRules === false && hasServers === false) return;
+	const content = renderConfigToml(hasRules ? renderInstructions(ruleFiles) : void 0, servers);
+	return createFileOutput(CONFIG_FILE, content, CONFIG_SOURCE);
+}
+/** The rule files as they are, with the header that names the source of each. */
+function renderInstructions(ruleFiles) {
+	const rules = ruleFiles.map((file) => file.content.trimEnd());
+	return `${[INSTRUCTIONS_INTRO, ...rules].join("\n\n")}\n`;
+}
+//#endregion
 //#region src/agents/adapters.ts
-/** Every supported agent; Codex comes in v0.2. */
-const AGENT_ADAPTERS = { [Agent.Claude]: claudeAdapter };
+/** Every supported agent. */
+const AGENT_ADAPTERS = {
+	[Agent.Claude]: claudeAdapter,
+	[Agent.Codex]: codexAdapter
+};
 //#endregion
 //#region src/shared/utils/markdown.ts
 /**
@@ -1040,7 +1198,7 @@ function renderLevelLine(rule) {
 //#endregion
 //#region src/generate/index-sections.ts
 const HIERARCHY_INTRO = "Instructions are ordered from specific to general. When two instructions conflict, follow the one from the higher level in this list.";
-const RULES_INTRO = "Always follow these rules. Claude Code loads them automatically; other agents should read them before starting work.";
+const RULES_INTRO = "Always follow these rules. Claude Code and Codex load them automatically; other agents should read them before starting work.";
 const SKILLS_INTRO = "Use a skill when the task matches its description.";
 const CHANGING_SECTION = [
 	"## Changing this setup",
@@ -1102,8 +1260,8 @@ function renderSkills(skills) {
 	}));
 	return renderSection("Skills", SKILLS_INTRO, table);
 }
-function renderCommands(commands) {
-	return renderSection("Commands", void 0, renderTable([
+function renderCommands(commands, agents) {
+	const table = renderTable([
 		"Command",
 		"Level",
 		"Description"
@@ -1115,7 +1273,18 @@ function renderCommands(commands) {
 			origin,
 			description
 		];
-	})));
+	}));
+	const hints = agents.map(describeCommandCall).filter(isString);
+	if (hints.length > 0) return renderSection("Commands", hints.join(" "), table);
+	return renderSection("Commands", void 0, table);
+}
+/** How to call a command in the agent, when it is not the usual `/<name>`. */
+function describeCommandCall(agent) {
+	switch (agent) {
+		case Agent.Claude: return;
+		case Agent.Codex: return "In Codex, a command is a skill with the same name: call it as `$<name>`.";
+		default: throw new TunestraError(`Unknown agent: ${agent}`);
+	}
 }
 function renderMcpServers(servers) {
 	return renderSection("MCP servers", void 0, renderTable([
@@ -1180,7 +1349,7 @@ function renderAgentsIndex(resolution) {
 		sections.push(skills);
 	}
 	if (hasCommands) {
-		const commands = renderCommands(resolution.commands);
+		const commands = renderCommands(resolution.commands, resolution.chain.project.agents);
 		sections.push(commands);
 	}
 	if (hasMcpServers) {
@@ -1209,6 +1378,7 @@ function planSetup(resolution) {
 	];
 	const ignoredPaths = [`${AGENTS_DIR}/`];
 	const protectedPaths = [INSTRUCTIONS_FILE];
+	const notes = [];
 	const context = {
 		resolution,
 		ruleFiles
@@ -1218,6 +1388,7 @@ function planSetup(resolution) {
 		outputs.push(...agentPlan.outputs);
 		ignoredPaths.push(...agentPlan.ignoredPaths);
 		protectedPaths.push(...agentPlan.protectedPaths);
+		notes.push(...agentPlan.notes);
 	}
 	ignoredPaths.push(`${STATE_DIR}/`);
 	const problems = findPathConflicts(outputs);
@@ -1225,7 +1396,8 @@ function planSetup(resolution) {
 	return {
 		outputs,
 		ignoredPaths,
-		protectedPaths
+		protectedPaths,
+		notes
 	};
 }
 function planRuleFile(projectDir, rule) {
@@ -1567,11 +1739,16 @@ async function inspectPath(path) {
 		return {
 			type,
 			hash: hashContent(content),
-			isMarked: content.subarray(0, 26).toString("utf8") === GENERATED_MARKER
+			isMarked: hasGeneratedMarker(content)
 		};
 	}
 	return { type };
 }
+function hasGeneratedMarker(content) {
+	return GENERATED_MARKERS.some((marker) => {
+		return content.subarray(0, marker.length).toString("utf8") === marker;
+	});
+}
 /** A file matches a record by its hash, a symlink by its target. */
 function matchesRecord(entry, record) {
 	if (entry.type === PathType.File && "hash" in record) return entry.hash === record.hash;
@@ -1719,6 +1896,7 @@ async function runSetup(projectDir, options) {
 	const sync = await planSync(chain.project.dir, plan, previous);
 	const report = {
 		resolution,
+		plan,
 		sync
 	};
 	if (options.dryRun) return report;
@@ -1763,26 +1941,30 @@ function measureColumn(rows, column) {
 //#region src/cli/commands/setup.ts
 async function describeSetup(projectDir, options) {
 	const report = await runSetup(projectDir, options);
-	const summary = describeSync(report.sync, options);
+	const summary = describeSync(report.plan, report.sync, options);
 	if (options.verbose) return `${describeResolution(report.resolution)}
 
 ${summary}`;
 	return summary;
 }
-function describeSync(sync, options) {
+function describeSync(plan, sync, options) {
 	const warningIcon = pc.yellow("⚠");
 	const lines = sync.warnings.map((warning) => `${warningIcon} ${warning}`);
+	const noteIcon = pc.cyan("ℹ");
+	const notes = plan.notes.map((note) => `${noteIcon} ${note}`);
 	const writeCount = sync.outputs.length;
 	const removeCount = sync.removals.length;
 	if (options.dryRun) {
 		const writes = sync.outputs.map((output) => `  write   ${output.path}`);
 		const removals = sync.removals.map((path) => `  remove  ${path}`);
-		lines.push(...writes, ...removals, "", "Nothing was written (--dry-run).");
+		lines.push(...writes, ...removals, ...notes, "", "Nothing was written (--dry-run).");
 		return lines.join("\n");
 	}
 	const check = pc.green("✔");
+	const committedFiles = plan.protectedPaths.join(" and ");
 	lines.push(`${check} Generated ${writeCount} files, removed ${removeCount} stale files.`);
-	lines.push("Commit AGENTS.md and CLAUDE.md; the rest is in .gitignore.");
+	lines.push(...notes);
+	lines.push(`Commit ${committedFiles}; the rest is in .gitignore.`);
 	return lines.join("\n");
 }
 //#endregion
@@ -1815,12 +1997,14 @@ async function runUninstall(projectDir, options) {
 		warnings
 	};
 	const stateDir = join(projectDir, STATE_DIR);
+	const tunestraDir = join(projectDir, PROJECT_DIR);
 	await removeOutputs(projectDir, removals);
 	await removeGitignoreBlockFile(projectDir);
 	await rm(stateDir, {
 		recursive: true,
 		force: true
 	});
+	await removeDirIfEmpty(tunestraDir);
 	return {
 		removals,
 		warnings

package/dist/index.mjs

@@ -1 +1 @@
-export { t as VERSION } from "./src-DSbrKtiC.mjs";
+export { t as VERSION } from "./src-jfoAZbqo.mjs";

package/dist/{src-DSbrKtiC.mjs → src-jfoAZbqo.mjs}

@@ -1,5 +1,5 @@
 //#endregion
 //#region src/index.ts
-const VERSION = "0.1.0";
+const VERSION = "0.2.0";
 //#endregion
 export { VERSION as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tunestra",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Tune your AI agents to play as one orchestra: one source of rules, skills, commands and MCP servers for Claude Code, Codex and more.",
   "keywords": [
     "ai",
@@ -44,7 +44,13 @@
     "test:watch": "vitest",
     "coverage": "vitest run --coverage",
     "check": "npm run typecheck && npm run lint && npm run test && npm run build",
-    "prepublishOnly": "npm run check"
+    "prepublishOnly": "npm run check",
+    "changeset": "changeset",
+    "version-packages": "changeset version && npm install --package-lock-only",
+    "release": "changeset publish"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "engines": {
     "node": ">=22.18"
@@ -54,12 +60,14 @@
     "commander": "^15.0.0",
     "giget": "^3.3.1",
     "picocolors": "^1.1.1",
+    "smol-toml": "^1.9.1",
     "tinyglobby": "^0.2.17",
     "yaml": "^2.9.1",
     "zod": "^4.6.7"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.15",
+    "@changesets/cli": "^3.0.3",
     "@types/node": "^22.20.5",
     "@vitest/coverage-v8": "^5.0.5",
     "tsdown": "^0.23.1",