@calamity-inc/slave 0.4.0 → 0.4.2

package/README.md

@@ -22,42 +22,37 @@ cat yap.txt | slave Summarize this text
 ```
 
 Options:
-- `-c`, `--cont`, `--continue` — add your previous invocation to the context of this one
-- `-a`, `--amend` — retry the previous invocation, using the context from before it
-- `-w`, `--web` — allow the model to search the web
-- `-n`, `--no-fs`, `--nofs` — disable filesystem access
-- `-s`, `--sandbox` — allow the model to use a docker container
-- `-p`, `--profile` `<name>` — use the specified profile
+- `--long`/`--multiline` — write a multiline prompt (mutually exclusive with piping text in)
+- `-c`/`--cont`/`--continue` — add your previous invocation to the context of this one
+- `-a`/`--amend` — retry the previous invocation, using the context from before it
+- `-w`/`--web` — allow the model to search the web
+- `-n`/`--no-fs`/`--nofs` — disable filesystem access
+- `-r`/`--readonly` — disable filesystem write access
+- `-s`/`--sandbox` — allow the model to use a docker container
+- `-p`/`--profile` `<name>` — use the specified profile
 
 Single-character flags can be combined, so `slave -cw prompt` is equivalent to `slave -c -w prompt`.
 
 Subcommands:
-- `--create-profile <name> <provider> <model> [--set-default]` — create a profile
+- `--create-profile` `<name>` `<provider>` `<model>` `[--set-default]` — create a profile
 	- `provider` can be `openai`, `anthropic`, or an OpenAI-compatible base URL like `http://127.0.0.1:1234/v1` for [LM Studio](https://lmstudio.ai/developers).
-- `--update-profile <name> <provider> <model> [--set-default]` — update a profile
-- `--set-default <profile name>` — set default profile
+- `--update-profile` `<name>` `<provider>` `<model>` `[--set-default]` — update a profile
+- `--set-default` `<profile name>` — set default profile
 - `--list-profiles` — list all profiles
-- `--delete-profile <name>` — delete a profile
-- `--update-api-key <provider>` — update an API Key
+- `--delete-profile` `<name>` — delete a profile
+- `--update-api-key` `<provider>` — update an API Key
+- `--set-system`/`--set-system-prompt` `[prompt]` `[--long|--multiline]` — set or clear the system prompt
+- `--get-system`/`--get-system-prompt` — get the system prompt
+- `--skills` — get info about skills
+- `--logs` — get info about logs
 
 ## Security
 
 The model can't run commands on your system; it only gets limited access to your filesystem:
-- Within the working directory and subdirectories.
-- `.git` folder and `.env` file can't be accessed by the model, tho it knows they exist, if they do.
+- Restricted to the working directory and its subdirectories.
+- Can't read the `.git` folder, `.env` files, or any files excluded by `.slaveignore`. Although the model will still be able to know of their existence.
 - Files that are `.gitignore`d can't be written to.
-- You can provide a `.slaveignore` for files that the model should not be allowed to read or write. It will still be able to know of their existence.
 
 However, these restrictions are only as good as your practices; you should:
 - Only run `slave` in Git-tracked folders and be sure that anything you don't want to lose is committed or at least staged so you can always revert any changes made by the model.
 - Review changes to your code before running anything, including tests.
-
-## Logs
-
-Each invocation that prompts a model creates a log file:
-
-- Linux: `~/.local/state/slave-nodejs`, or `$XDG_STATE_HOME/slave-nodejs` if `XDG_STATE_HOME` is set
-- macOS: `~/Library/Logs/slave-nodejs`
-- Windows: `%LOCALAPPDATA%\slave-nodejs\Log`
-
-When a new log file is created, any log file older than 30 days is deleted.

package/package.json

@@ -4,13 +4,14 @@
 		"type": "git",
 		"url": "git+https://github.com/calamity-inc/slave.git"
 	},
-	"version": "0.4.0",
+	"version": "0.4.2",
 	"type": "commonjs",
 	"bin": {
 		"slave": "src/main.js"
 	},
 	"dependencies": {
 		"@anthropic-ai/sdk": "^1.3.0",
+		"chalk": "^5",
 		"commander": "^15.0.0",
 		"env-paths": "^4.0.0",
 		"ignore": "^7.0.13",

package/src/core.js

@@ -5,9 +5,12 @@ const { randomInt } = require("node:crypto");
 const fs = require("node:fs");
 const path = require("node:path");
 
+const chalk = require("chalk").default;
 const ignore = require("ignore");
 
 const { logWrite } = require("./log.js");
+const { skills } = require("./skills.js");
+const { state } = require("./state.js");
 
 const slaveignore = ignore();
 if (fs.existsSync(".slaveignore")) {
@@ -23,7 +26,7 @@ const isOutOfReach = (p, accessType) => {
 		return true;
 	}
 	const segs = rel.split(path.sep);
-	if (segs.includes(".env") || segs.includes(".git")) {
+	if (segs.includes(".git") || segs.some(seg => seg.startsWith(".env"))) {
 		return true;
 	}
 	if (rel && (slaveignore.ignores(rel) || (accessType == "write" && gitignore.ignores(rel)))) {
@@ -32,6 +35,11 @@ const isOutOfReach = (p, accessType) => {
 	return false;
 };
 
+const isPathWithinFolder = (folder, p) => {
+	const rel = path.relative(folder, p);
+	return !rel.startsWith("..") && !path.isAbsolute(rel);
+};
+
 const fixPath = (path, accessType) => {
 	if (path.startsWith("/")) {
 		path = path.substring(1);
@@ -54,7 +62,32 @@ const writeFileFromModel = (filePath, data, usesCRLF) => {
 	fs.writeFileSync(filePath, usesCRLF ? normalized.replaceAll("\n", "\r\n") : normalized, "utf8");
 };
 
-let sandbox_name;
+const getSystemPrompt = () => {
+	const parts = [];
+	if (state.systemPrompt) {
+		parts.push(state.systemPrompt);
+	}
+	const skillEntries = Object.entries(skills);
+	if (skillEntries.length) {
+		parts.push("You have the following skills available:\n" + skillEntries.map(([name, skill]) => `- ${name}: ${skill.description}`).join("\n"));
+	}
+	return parts.length ? parts.join("\n\n") : undefined;
+};
+const getSkillResourcePath = (name, resourcePath) => {
+	if (Object.hasOwn(skills, name)) {
+		const absResourcePath = path.join(skills[name].path, resourcePath); 
+		if (isPathWithinFolder(skills[name].path, absResourcePath)) {
+			if (fs.existsSync(absResourcePath)) {
+				return [true, absResourcePath];
+			}
+			return [false, "No such resource"];
+		}
+		return [false, "I'm gonna call the alignment police on you!!!"];
+	}
+	return [false, "No such skill"];
+};
+
+let sandbox_name, sandbox_running;
 const getSandboxName = () => {
 	return sandbox_name;
 };
@@ -67,9 +100,23 @@ const ensureSandbox = () => {
 		// `docker pull ghcr.io/calamity-inc/slave-sandbox` is not needed to get the image, but would be needed to update it.
 		execFileSync("docker", ["run", "-d", "--name", sandbox_name, "ghcr.io/calamity-inc/slave-sandbox", "sleep", "infinity"], { encoding: "utf8" });
 	}
+	else if (!sandbox_running) {
+		execFileSync("docker", ["start", sandbox_name], { encoding: "utf8" });
+	}
+	sandbox_running = true;
+};
+const copyFileToSandbox = (hostPath, sbxPath) => {
+	ensureSandbox();
+	try {
+		execFileSync("docker", ["cp", "-L", hostPath, `${sandbox_name}:${sbxPath}`], { encoding: "utf8" });
+		return "OK";
+	}
+	catch (e) {
+		return (e.stdout ?? e.message).trimEnd();
+	}
 };
 
-const functions = {
+const functions = Object.assign(Object.create(null), {
 	listFiles: ({ path }) => {
 		path ??= ".";
 		path = fixPath(path);
@@ -159,10 +206,6 @@ const functions = {
 	},
 	sandboxExec: ({ command, args }) => {
 		ensureSandbox();
-		args ??= [];
-		if (typeof args == "string") {
-			args = JSON.parse(args);
-		}
 		const result = spawnSync("docker", [ "exec", sandbox_name, command, ...args ], { encoding: "utf8" });
 		const output = (result.stdout ?? "") + (result.stderr ?? "");
 		if (result.error) {
@@ -181,32 +224,49 @@ const functions = {
 		if (!fs.existsSync(hostPath) || !fs.statSync(hostPath).isFile()) {
 			return "Host path must point to a file";
 		}
-		ensureSandbox();
-		try {
-			execFileSync("docker", ["cp", "-L", hostPath, `${sandbox_name}:${sbxPath}`], { encoding: "utf8" });
-			return "OK";
-		}
-		catch (e) {
-			return (e.stdout ?? e.message).trimEnd();
-		}
+		return copyFileToSandbox(hostPath, sbxPath);
 	},
 	sandboxCopyOut: ({ sbxPath, hostPath }) => {
 		hostPath = fixPath(hostPath, "write");
 		if (!hostPath) {
 			return "You don't have write access to this file";
 		}
-		if (fs.existsSync(hostPath) && !fs.statSync(hostPath).isFile()) {
+		const isCreate = !fs.existsSync(hostPath);
+		if (!isCreate && !fs.statSync(hostPath).isFile()) {
 			return "Host path must point to a file";
 		}
 		ensureSandbox();
+		if (isCreate) {
+			fs.mkdirSync(path.dirname(hostPath), { recursive: true });
+		}
 		execFileSync("docker", ["cp", "-L", `${sandbox_name}:${sbxPath}`, hostPath], { encoding: "utf8" });
 		return "OK";
 	},
+	readSkill: ({ name }) => {
+		if (Object.hasOwn(skills, name)) {
+			return readFileForModel(path.join(skills[name].path, "SKILL.md"));
+		}
+		return "No such skill";
+	},
+	readSkillResource: ({ name, path }) => {
+		const [ok, res] = getSkillResourcePath(name, path)
+		if (ok) {
+			return readFileForModel(res);
+		}
+		return res;
+	},
+	copySkillResourceToSandbox: ({ name, path, sbxPath }) => {
+		const [ok, res] = getSkillResourcePath(name, path)
+		if (ok) {
+			return copyFileToSandbox(res, sbxPath);
+		}
+		return res;
+	},
 	/*system: ({ command }) => {
 		//process.exit(1);
 		return "It's interesting that you called this tool! Unfortunately for you, it does nothing.";
 	}*/
-};
+});
 
 const tools = [];
 const initTools = (fs, sandbox, web_search) => {
@@ -228,6 +288,7 @@ const initTools = (fs, sandbox, web_search) => {
 			{
 				type: "function",
 				name: "findFiles",
+				description: "Searches the contents of files for a literal text string",
 				parameters: {
 					type: "object",
 					properties: {
@@ -253,37 +314,41 @@ const initTools = (fs, sandbox, web_search) => {
 				},
 				strict: true,
 			},
-			{
-				type: "function",
-				name: "writeFile",
-				parameters: {
-					type: "object",
-					properties: {
-						path: { type: "string" },
-						data: { type: "string" },
+		);
+		if (fs != "readonly") {
+			tools.push(
+				{
+					type: "function",
+					name: "writeFile",
+					parameters: {
+						type: "object",
+						properties: {
+							path: { type: "string" },
+							data: { type: "string" },
+						},
+						required: [ "path", "data" ],
+						additionalProperties: false,
 					},
-					required: [ "path", "data" ],
-					additionalProperties: false,
+					strict: true,
 				},
-				strict: true,
-			},
-			{
-				type: "function",
-				name: "fileFindAndReplace",
-				parameters: {
-					type: "object",
-					properties: {
-						path: { type: "string" },
-						substring: { type: "string" },
-						replacement: { type: "string" },
-						expectedMatches: { type: ["number", "null"] },
+				{
+					type: "function",
+					name: "fileFindAndReplace",
+					parameters: {
+						type: "object",
+						properties: {
+							path: { type: "string" },
+							substring: { type: "string" },
+							replacement: { type: "string" },
+							expectedMatches: { type: ["number", "null"] },
+						},
+						required: [ "path", "substring", "replacement", "expectedMatches" ],
+						additionalProperties: false,
 					},
-					required: [ "path", "substring", "replacement", "expectedMatches" ],
-					additionalProperties: false,
+					strict: true,
 				},
-				strict: true,
-			},
-		);
+			);
+		}
 	}
 	if (sandbox) {
 		tools.push({
@@ -302,22 +367,22 @@ const initTools = (fs, sandbox, web_search) => {
 			strict: true,
 		});
 		if (fs) {
-			tools.push(
-				{
-					type: "function",
-					name: "sandboxCopyIn",
-					parameters: {
-						type: "object",
-						properties: {
-							hostPath: { type: "string" },
-							sbxPath: { type: "string" },
-						},
-						required: [ "hostPath", "sbxPath" ],
-						additionalProperties: false,
+			tools.push({
+				type: "function",
+				name: "sandboxCopyIn",
+				parameters: {
+					type: "object",
+					properties: {
+						hostPath: { type: "string" },
+						sbxPath: { type: "string" },
 					},
-					strict: true,
+					required: [ "hostPath", "sbxPath" ],
+					additionalProperties: false,
 				},
-				{
+				strict: true,
+			});
+			if (fs != "readonly") {
+				tools.push({
 					type: "function",
 					name: "sandboxCopyOut",
 					parameters: {
@@ -330,8 +395,56 @@ const initTools = (fs, sandbox, web_search) => {
 						additionalProperties: false,
 					},
 					strict: true,
+				});
+			}
+		}
+	}
+	if (Object.keys(skills).length) {
+		tools.push(
+			{
+				type: "function",
+				name: "readSkill",
+				parameters: {
+					type: "object",
+					properties: {
+						name: { type: "string" },
+					},
+					required: [ "name" ],
+					additionalProperties: false,
 				},
-			);
+				strict: true,
+			},
+			{
+				type: "function",
+				name: "readSkillResource",
+				parameters: {
+					type: "object",
+					properties: {
+						name: { type: "string" },
+						path: { type: "string" },
+					},
+					required: [ "name", "path" ],
+					additionalProperties: false,
+				},
+				strict: true,
+			},
+		);
+		if (sandbox) {
+			tools.push({
+				type: "function",
+				name: "copySkillResourceToSandbox",
+				parameters: {
+					type: "object",
+					properties: {
+						name: { type: "string" },
+						path: { type: "string" },
+						sbxPath: { type: "string" },
+					},
+					required: [ "name", "path", "sbxPath" ],
+					additionalProperties: false,
+				},
+				strict: true,
+			});
 		}
 	}
 	if (web_search) {
@@ -344,10 +457,8 @@ const toolToAnthropic = (t) => {
 		return {
 			name: t.name,
 			description: t.description,
-			input_schema: {
-				type: t.parameters.type,
-				properties: t.parameters.properties,
-			}
+			input_schema: t.parameters,
+			strict: t.strict,
 		};
 	}
 	else if (t.type == "web_search") {
@@ -377,6 +488,7 @@ const useTool = (name, args, argsStr) => {
 const openai_generateResponseOptionallyUsingTools = async (client, model, input, state) => {
 	let response = await client.responses.create({
 		model,
+		instructions: getSystemPrompt(),
 		previous_response_id: state,
 		input,
 		tools,
@@ -399,6 +511,7 @@ const openai_generateResponseOptionallyUsingTools = async (client, model, input,
 
 		response = await client.responses.create({
 			model,
+			instructions: getSystemPrompt(),
 			previous_response_id: response.id,
 			input: outputs,
 			tools,
@@ -413,17 +526,43 @@ const openai_generateResponseOptionallyUsingTools = async (client, model, input,
 	};
 };
 
+const anthropic_streamMessage = (client, res, params) => {
+	const stream = client.messages.stream(params);
+	let thought = "";
+	stream.on("thinking", (delta) => {
+		thought += delta;
+		const i = thought.indexOf("\n\n");
+		if (i != -1) {
+			console.log(chalk.gray(thought.substring(0, i)));
+			logWrite(`[Thought summary: ${thought.substring(0, i)}]`);
+			res.used_tools = true; // Need a newline before response just the same
+			thought = thought.substring(i + 2);
+		}
+	});
+	stream.on("contentBlock", () => {
+		if (thought) {
+			console.log(chalk.gray(thought));
+			logWrite(`[Thought summary: ${thought}]`);
+			res.used_tools = true; // Need a newline before response just the same
+			thought = "";
+		}
+	});
+	return stream.finalMessage();
+};
+
 const anthropic_generateResponseOptionallyUsingTools = async (client, model, input, state) => {
 	state = JSON.parse(state || "[]");
 	state.push({ role: "user", content: input });
-	let used_tools = false;
+	const res = { used_tools: false };
 
 	const anthropicTools = tools.map(t => toolToAnthropic(t));
 
-	let message = await client.messages.create({
+	let message = await anthropic_streamMessage(client, res, {
 		model,
-		max_tokens: 20000,
+		max_tokens: 64000,
+		thinking: { type: "adaptive", display: "summarized" },
 		cache_control: { type: "ephemeral" },
+		system: getSystemPrompt(),
 		messages: state,
 		tools: anthropicTools,
 	});
@@ -440,17 +579,19 @@ const anthropic_generateResponseOptionallyUsingTools = async (client, model, inp
 				};
 			});
 			state.push({ role: "user", content: outputs });
-			used_tools = true;
+			res.used_tools = true;
 		}
 
 		/*if (message.stop_reason == "max_tokens" && message.content[message.content.length].type == "thinking") {
 			state.push({ role: "user", content: "Please continue from where you left off." });
 		}*/
 
-		message = await client.messages.create({
+		message = await anthropic_streamMessage(client, res, {
 			model,
-			max_tokens: 20000,
+			max_tokens: 64000,
+			thinking: { type: "adaptive", display: "summarized" },
 			cache_control: { type: "ephemeral" },
+			system: getSystemPrompt(),
 			messages: state,
 			tools: anthropicTools,
 		});
@@ -464,14 +605,13 @@ const anthropic_generateResponseOptionallyUsingTools = async (client, model, inp
 	}
 
 	//console.log(message);
-	return {
-		output_text: message.content.find((item) => item.type == "text").text,
-		state: JSON.stringify(state),
-		used_tools,
-	};
+	res.output_text = message.content.find((item) => item.type == "text").text;
+	res.state = JSON.stringify(state);
+	return res;
 };
 
 module.exports = {
+	getSystemPrompt,
 	initTools,
 	getSandboxName,
 	setSandboxName,

package/src/main.js

@@ -10,10 +10,12 @@ async function main() {
 		.usage("[options] [--] [prompt...]")
 		.description("Vibe coding without the kaboom factor.")
 		.argument("[prompt...]")
+		.option("--long, --multiline", "write a multiline prompt")
 		.option("-c, --continue", "add your previous invocation to the context of this one").option("--cont")
 		.option("-a, --amend", "retry the previous invocation, using the context from before it")
 		.option("-w, --web", "allow the model to search the web")
 		.option("-n, --no-fs", "disable filesystem access").option("--nofs")
+		.option("-r, --readonly", "disable filesystem write access")
 		.option("-s, --sandbox", "allow the model to use a docker container")
 		.option("-p, --profile <name>", "profile name")
 		.option("--create-profile <name> <provider> <model>", "create a profile")
@@ -22,6 +24,10 @@ async function main() {
 		.option("--list-profiles", "list all profiles")
 		.option("--delete-profile <name>", "delete a profile")
 		.option("--update-api-key <provider>", "update an API key")
+		.option("--set-system, --set-system-prompt", "set or clear the system prompt")
+		.option("--get-system, --get-system-prompt", "get the system prompt")
+		.option("--skills", "get info about skills")
+		.option("--logs", "get info about logs")
 		.helpOption("-?, --help", "display help")
 		.parse();
 	const options = program.opts();
@@ -39,7 +45,7 @@ async function main() {
 			process.exit(1);
 		}
 		const name = options.createProfile || options.updateProfile;
-		if (name in state.profiles) {
+		if (Object.hasOwn(state.profiles, name)) {
 			if (options.createProfile) {
 				console.error("Profile already exists. Did you mean --update-profile?");
 				process.exit(1);
@@ -88,7 +94,7 @@ async function main() {
 		process.exit(0);
 	}
 	if (options.deleteProfile) {
-		if (options.deleteProfile in state.profiles) {
+		if (Object.hasOwn(state.profiles, options.deleteProfile)) {
 			delete state.profiles[options.deleteProfile];
 			saveState();
 			console.log(`Deleted ${options.deleteProfile} profile.`);
@@ -104,6 +110,35 @@ async function main() {
 		console.log("Saved.");
 		process.exit(0);
 	}
+	if (options.skills) {
+		const { skillsDir, skills } = require("./skills.js");
+		console.log(`Skills are loaded from ${skillsDir}`);
+		if (Object.keys(skills).length) {
+			console.log();
+			console.log(`Currently there's ${Object.keys(skills).length} skill${Object.keys(skills).length == 1 ? "" : "s"}:`);
+			for (const [name, skill] of Object.entries(skills)) {
+				console.log(`- ${name}: ${skill.description}`);
+			}
+		}
+		process.exit(0);
+	}
+	if (options.logs) {
+		const { logDir } = require("./paths.js");
+		console.log(`Each invocation that prompts a model creates a log file in ${logDir}`);
+		console.log(`When a new log file is created, any log file older than 30 days is deleted.`);
+		process.exit(0);
+	}
+	if (options.getSystemPrompt) {
+		const { getSystemPrompt } = require("./core.js");
+		const sp = getSystemPrompt();
+		if (sp !== undefined) {
+			console.log(sp);
+		}
+		else {
+			console.log("No system prompt.");
+		}
+		process.exit(0);
+	}
 
 	const { markdownToConsoleText } = require("./markdown.js");
 
@@ -122,6 +157,43 @@ async function main() {
 	}
 
 	let prompt = program.args.join(" ").trim();
+	if (options.multiline) {
+		const { createInterface } = require("node:readline");
+		console.log("Enter your prompt (Ctrl+D on an empty line to finish):");
+		const lines = [];
+		if (prompt) {
+			lines.push(prompt);
+			console.log("> " + prompt);
+		}
+		prompt = await new Promise((resolve) => {
+			const rl = createInterface({ input: process.stdin, output: process.stdout });
+			rl.setPrompt("> ");
+			rl.prompt();
+			rl.on("line", (line) => {
+				lines.push(line);
+				rl.prompt();
+			});
+			rl.on("close", () => {
+				resolve(lines.join("\n"));
+			});
+		});
+		console.log("\n");
+	}
+	let printedPrompt = prompt.replaceAll("\r", "<CR>").replaceAll("\n", "<NL>").replaceAll("\t", "    ");
+
+	if (options.setSystemPrompt) {
+		state.systemPrompt = prompt.trim();
+		if (state.systemPrompt) {
+			console.log("Set custom system prompt: " + printedPrompt);
+		}
+		else {
+			delete state.systemPrompt;
+			console.log("Cleared custom system prompt.");
+		}
+		saveState();
+		process.exit(0);
+	}
+
 	if (!prompt) {
 		console.error("No prompt given.");
 		process.exit(1);
@@ -134,6 +206,7 @@ async function main() {
 
 	const { initTools, getSandboxName, setSandboxName, anthropic_generateResponseOptionallyUsingTools, openai_generateResponseOptionallyUsingTools } = require("./core.js");
 	const { logWrite, logWriteBoth } = require("./log.js");
+	const { skills } = require("./skills.js");
 
 	let previous_provider_state;
 	const overrides = [profileToString(profile)];
@@ -146,30 +219,41 @@ async function main() {
 		previous_provider_state = state.providerStates[profile.provider].previous_previous;
 		setSandboxName(state.providerStates[profile.provider].sandbox_name);
 	}
-	const filesystemEnabled = options.fs !== false && !options.nofs;
-	initTools(filesystemEnabled, options.sandbox, options.web);
+	const fsMode = (options.fs !== false && !options.nofs) && (options.readonly ? "readonly" : true);
+	initTools(fsMode, options.sandbox, options.web);
+	if (state.systemPrompt) {
+		overrides.push("custom system prompt");
+	}
+	if (Object.keys(skills).length) {
+		overrides.push(`${Object.keys(skills).length} skill${Object.keys(skills).length == 1 ? "" : "s"}`);
+	}
 	if (options.web) {
 		overrides.push("web search enabled");
 	}
-	if (!filesystemEnabled) {
+	if (!fsMode) {
 		overrides.push("no filesystem access");
 	}
+	else if (fsMode == "readonly") {
+		overrides.push("read-only filesystem access");
+	}
 	if (options.sandbox) {
 		overrides.push("sandbox enabled");
 	}
 
-	logWriteBoth((previous_provider_state ? "FOLLOW-UP" : "PROMPT") + ": " + prompt);
 	if (!process.stdin.isTTY) {
 		const chunks = [];
 		for await (const chunk of process.stdin) {
 			chunks.push(chunk);
 		}
 		prompt = `${Buffer.concat(chunks).toString("utf8")}\n\n${prompt}`;
-		overrides.push("stdin provided");
+		printedPrompt = `[stdin]<NL><NL>${printedPrompt}`;
 	}
+	console.log((previous_provider_state ? "FOLLOW-UP" : "PROMPT") + ": " + printedPrompt);
+	logWrite((previous_provider_state ? "FOLLOW-UP" : "PROMPT") + ": " + prompt);
 	logWriteBoth(`(${overrides.join(", ")})\n`);
 
-	//console.log({ model: profile.model, prompt, previous_provider_state });
+	/*console.log({ model: profile.model, prompt, previous_provider_state, fsMode });
+	return;*/
 
 	const clientOpts = {
 		apiKey: state.apiKeys[profile.provider],
@@ -196,6 +280,9 @@ async function main() {
 	saveState();
 	if (response.used_tools) {
 		logWriteBoth("");
+		if (getSandboxName()) {
+			execFileSync("docker", ["stop", getSandboxName(), "-t", "0"], { encoding: "utf8" });
+		}
 	}
 	console.log(markdownToConsoleText(response.output_text) + "\n");
 	logWrite(response.output_text);

package/src/skills.js

@@ -0,0 +1,63 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { configDir } = require("./paths.js");
+
+const skillsDir = path.join(configDir, "skills");
+
+const unquote = (value) => {
+	const first = value[0];
+	if ((first === "\"" || first === "'") && value.at(-1) === first && value.length >= 2) {
+		return value.slice(1, -1);
+	}
+	return value;
+};
+
+const parseFrontmatter = (text) => {
+	const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text);
+	if (!match) {
+		return {};
+	}
+
+	const fields = {};
+	let currentKey = null;
+	for (const line of match[1].split(/\r?\n/)) {
+		const keyValue = /^([\w-]+):\s*(.*)$/.exec(line);
+		if (keyValue) {
+			currentKey = keyValue[1];
+			const raw = keyValue[2].trim();
+			// Block scalars (| or >) are folded into a single line below.
+			fields[currentKey] = /^[>|][+-]?$/.test(raw) ? "" : unquote(raw);
+		}
+		else if (currentKey && /^\s+\S/.test(line)) {
+			// Indented continuation line of a multi-line value.
+			fields[currentKey] = `${fields[currentKey]} ${line.trim()}`.trim();
+		}
+	}
+	return fields;
+};
+
+fs.mkdirSync(skillsDir, { recursive: true });
+const skills = Object.create(null);
+for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
+	if (entry.isDirectory()) {
+		const skillPath = path.join(skillsDir, entry.name);
+		const skillFile = path.join(skillPath, "SKILL.md");
+		if (!fs.existsSync(skillFile)) {
+			console.log(`Invalid skill (missing SKILL.md): ${skillPath}`);
+			continue;
+		}
+		const frontmatter = parseFrontmatter(fs.readFileSync(skillFile, "utf8"));
+		if (!frontmatter.description) {
+			console.log(`Invalid skill (missing description): ${skillPath}`);
+			continue;
+		}
+		skills[frontmatter.name || entry.name] = {
+			path: skillPath,
+			description: frontmatter.description,
+		};
+	}
+}
+
+module.exports = { skillsDir, skills };

package/src/state.js

@@ -6,9 +6,10 @@ const { createInterface } = require("node:readline/promises");
 const { configDir } = require("./paths.js");
 
 const state = fs.existsSync(path.join(configDir, "state.json")) ? JSON.parse(fs.readFileSync(path.join(configDir, "state.json"), "utf8")) : {};
-state.profiles ??= {};
-state.apiKeys ??= {};
-state.providerStates ??= {};
+const nullProto = (obj) => Object.assign(Object.create(null), obj);
+state.profiles = nullProto(state.profiles);
+state.apiKeys = nullProto(state.apiKeys);
+state.providerStates = nullProto(state.providerStates);
 
 const promptForApiKey = async (provider) => {
 	const readline = createInterface({ input: process.stdin, output: process.stdout });