@calamity-inc/slave 0.1.0 → 0.2.0

package/.slaveignore

@@ -0,0 +1 @@
+.state.json

package/README.md

@@ -2,17 +2,16 @@
 
 Vibe coding without the kaboom factor.
 
-## Installation
+## Setup
 
-```
-npm i -g @calamity-inc/slave
-```
+1. Install slave: `npm i -g @calamity-inc/slave`
+2. Create a default profile, e.g. `slave --create-profile default openai gpt-6-luna`
 
 ## Usage
 
 In any directory:
 ```
-slave [flags] [--] How do I use the 'slave' command?
+slave [options] [--] How do I use the 'slave' command?
 ```
 
 You can also pipe text in:
@@ -20,19 +19,28 @@ You can also pipe text in:
 cat yap.txt | slave Summarize this text
 ```
 
-Flags:
+Options:
 - `-c`, `--cont`, `--continue` — add your previous invocation to the context of this one
+- `--amend` — retry the previous invocation, using the context from before it
 - `-w`, `--web` — allow the model to search the web
-- `-n`, `--no-fs`, `--nofs` — disables filesystem access so you can just have a non-binding chat with the model
+- `-n`, `--no-fs`, `--nofs` — disable filesystem access
+- `-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>` — creates a profile
+	- `provider` can be `openai` or an OpenAI-compatible base URL, e.g. `http://127.0.0.1:1234/v1` for [LM Studio](https://lmstudio.ai/developers).
+- `--delete-profile <name>` — deletes a profile
+- `--update-api-key <provider>` — updates an API Key
+
 ## Sandboxing / Security
 
 The model gets no command prompt access and limited access to your filesystem:
 - Only 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.
 - 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.

package/index.js

@@ -5,42 +5,43 @@ import { fileURLToPath } from "node:url";
 import { parseEnv } from "node:util";
 import { createInterface } from "node:readline/promises";
 import ignore from "ignore";
+import { Command } from "commander";
 import { marked } from "marked";
 import { markedTerminal } from "marked-terminal";
 import OpenAI from "openai";
 
 const configDir = path.dirname(fileURLToPath(import.meta.url));
-const env = fs.existsSync(path.join(configDir, ".env")) ? parseEnv(fs.readFileSync(path.join(configDir, ".env"), "utf8")) : {};
-if (!env.OPENAI_API_KEY) {
-	if (!process.stdin.isTTY) {
-		console.error(`No OPENAI_API_KEY found. Run this command in a terminal to enter your key, or add it to ${path.join(configDir, ".env")}.`);
-		process.exit(1);
+const state = fs.existsSync(path.join(configDir, ".state.json")) ? JSON.parse(fs.readFileSync(path.join(configDir, ".state.json"), "utf8")) : {};
+state.profiles ??= {};
+state.apiKeys ??= {};
+if (!state.apiKeys.openai && fs.existsSync(path.join(configDir, ".env"))) {
+	const env = parseEnv(fs.readFileSync(path.join(configDir, ".env"), "utf8"));
+	if (env.OPENAI_API_KEY) {
+		state.apiKeys.openai = env.OPENAI_API_KEY;
 	}
-
+}
+const promptForApiKey = async (provider) => {
 	const readline = createInterface({ input: process.stdin, output: process.stdout });
 	try {
-		env.OPENAI_API_KEY = (await readline.question("Enter your OpenAI API key: ")).trim();
+		state.apiKeys[provider] = (await readline.question("Enter your API key: ")).trim();
 	}
 	finally {
 		readline.close();
 	}
-	if (!env.OPENAI_API_KEY) {
-		console.error("An API key is required.");
-		process.exit(1);
-	}
+};
+const saveState = () => {
+	fs.writeFileSync(path.join(configDir, ".state.json"), JSON.stringify(state, null, 2), { encoding: "utf8", mode: 0o600 });
+	fs.chmodSync(path.join(configDir, ".state.json"), 0o600);
+};
 
-	fs.writeFileSync(path.join(configDir, ".env"), `OPENAI_API_KEY=${env.OPENAI_API_KEY}`, { encoding: "utf8", mode: 0o600 });
-	fs.chmodSync(path.join(configDir, ".env"), 0o600);
+const slaveignore = ignore();
+if (fs.existsSync(".slaveignore")) {
+	slaveignore.add(fs.readFileSync(".slaveignore", "utf8").replaceAll("/\n", "\n"));
 }
-const client = new OpenAI({
-	apiKey: env.OPENAI_API_KEY,
-});
-
 const gitignore = ignore();
 if (fs.existsSync(".gitignore")) {
 	gitignore.add(fs.readFileSync(".gitignore", "utf8").replaceAll("/\n", "\n"));
 }
-
 const isOutOfReach = (p, type) => {
 	const rel = path.relative(".", p);
 	if (rel.startsWith("..") || path.isAbsolute(rel)) {
@@ -50,12 +51,26 @@ const isOutOfReach = (p, type) => {
 	if (segs.includes(".env") || segs.includes(".git")) {
 		return true;
 	}
-	if (type == "write" && rel && gitignore.ignores(rel)) {
+	if (rel && (slaveignore.ignores(rel) || (type == "write" && gitignore.ignores(rel)))) {
 		return true;
 	}
 	return false;
 };
 
+const readFileForModel = (filePath) => fs.readFileSync(filePath, "utf8").replaceAll("\r\n", "\n");
+const writeFileFromModel = (filePath, data, usesCRLF) => {
+	if (fs.existsSync(filePath)) {
+		if (usesCRLF === undefined) {
+			usesCRLF = fs.readFileSync(filePath, "utf8").includes("\r\n");
+		}
+	}
+	else {
+		fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	}
+	const normalized = data.replaceAll("\r\n", "\n");
+	fs.writeFileSync(filePath, usesCRLF ? normalized.replaceAll("\n", "\r\n") : normalized, "utf8");
+};
+
 const functions = {
 	ls: ({ path }) => {
 		path ??= ".";
@@ -93,7 +108,7 @@ const functions = {
 			.filter(file => !isOutOfReach(file));
 		const res = [];
 		for (const file of files) {
-			const matches = fs.readFileSync(file, "utf8").split(substring).length - 1;
+			const matches = readFileForModel(file).split(substring).length - 1;
 			if (matches) {
 				res.push(`${file} has ${matches} match${matches == 1 ? "" : "es"}`);
 			}
@@ -104,25 +119,27 @@ const functions = {
 		if (isOutOfReach(path)) {
 			return "Out of your reach";
 		}
-		return fs.readFileSync(path, "utf8");
+		return readFileForModel(path);
 	},
 	writeFile: ({ path, data }) => {
 		if (isOutOfReach(path, "write")) {
 			return "Out of your reach";
 		}
-		fs.writeFileSync(path, data, "utf8");
+		writeFileFromModel(path, data);
 		return "OK";
 	},
 	fileFindAndReplace: ({ path, substring, replacement, expectedMatches }) => {
 		if (isOutOfReach(path, "write")) {
 			return "Out of your reach";
 		}
-		const arr = fs.readFileSync(path, "utf8").split(substring);
+		const fileContent = fs.readFileSync(path, "utf8");
+		const usesCRLF = fileContent.includes("\r\n");
+		const arr = fileContent.replaceAll("\r\n", "\n").split(substring);
 		const matches = arr.length - 1;
 		if (matches == 0 || (expectedMatches && matches != expectedMatches)) {
 			return `There were ${matches} match${matches == 1 ? "" : "es"}`;
 		}
-		fs.writeFileSync(path, arr.join(replacement), "utf8");
+		writeFileFromModel(path, arr.join(replacement), usesCRLF);
 		return "OK";
 	},
 	system: ({ command }) => {
@@ -220,8 +237,7 @@ let tools = [
 	},*/
 ];
 
-const generateResponseOptionallyUsingTools = async (input, previous_response_id) => {
-	const model = "gpt-6-luna";
+const generateResponseOptionallyUsingTools = async (client, model, input, previous_response_id) => {
 	let response = await client.responses.create({
 		model,
 		previous_response_id,
@@ -268,54 +284,90 @@ marked.use(markedTerminal());
 const markdownToConsoleText = (md) => {
 	const _console_error = console.error; // prevent unintended output about unknown languages, e.g. "```env\ndeez\n```\n"
 	console.error = undefined;
-	const text = marked.parse(md);
+	const text = marked.parse(md).trimEnd() + "\n";
 	console.error = _console_error;
 	return text;
 };
 
-let i = 2;
-let previous_response_id;
-const overrides = [];
-const processFlag = (flag) => {
-	if (flag == "-c" || flag == "--cont" || flag == "--continue") {
-		if (fs.existsSync(path.join(configDir, ".state.json"))) {
-			previous_response_id = JSON.parse(fs.readFileSync(path.join(configDir, ".state.json"), "utf8")).previous_response_id;
-		}
-	}
-	else if (flag == "-w" || flag == "--web") {
-		if (!overrides.includes("web search enabled")) {
-			tools.push({ type: "web_search" });
-			overrides.push("web search enabled");
-		}
-	}
-	else if (flag == "-n" || flag == "--no-fs" || flag == "--nofs") {
-		if (!overrides.includes("no filesystem access")) {
-			tools = tools.filter(tool => tool.type != "function");
-			overrides.push("no filesystem access");
-		}
+
+const program = new Command();
+program
+	.name("slave")
+	.usage("[options] [--] [prompt...]")
+	.description("Vibe coding without the kaboom factor.")
+	.argument("[prompt...]")
+	.option("-c, --continue", "add your previous invocation to the context of this one").option("--cont")
+	.option("--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("-p, --profile <name>", "profile name", "default")
+	.option("--create-profile <name> <provider> <model>", "create a profile")
+	.option("--delete-profile <name>", "delete a profile") // TODO
+	.option("--update-api-key <provider>", "update an API key") // TODO
+	.helpOption("-?, --help", "display help")
+	.parse();
+const options = program.opts();
+
+if (options.createProfile) {
+	if (!program.args[0] || !program.args[1]) {
+		console.log("Syntax: slave --create-profile <name> <provider> <model>");
+		process.exit(1);
 	}
-	else {
-		console.log(`Unknown flag: ${flag}`);
+	const provider = program.args[0];
+	if (provider != "openai" && !provider.startsWith("http://") && !provider.startsWith("https://")) {
+		console.log(`Invalid provider: ${provider}`);
+		process.exit(1);
 	}
-};
-for (; i != process.argv.length; ++i) {
-	const argument = process.argv[i];
-	if (!argument.startsWith("-")) {
-		break;
+	const isCreate = !(options.createProfile in state.profiles);
+	state.profiles[options.createProfile] = { provider, model: program.args[1] };
+	if (!state.apiKeys[provider]) {
+		await promptForApiKey(provider);
 	}
-	if (argument == "--") {
-		++i;
-		break;
+	saveState();
+	console.log(`${isCreate ? "Created" : "Updated"} ${options.createProfile} profile.`);
+	process.exit(0);
+}
+if (options.deleteProfile) {
+	delete state.profiles[options.deleteProfile];
+	saveState();
+	console.log(`Deleted ${options.deleteProfile} profile.`);
+	process.exit(0);
+}
+if (options.updateApiKey) {
+	await promptForApiKey(options.updateApiKey);
+	saveState();
+	console.log("Saved.");
+	process.exit(0);
+}
+
+const profile = state.profiles[options.profile];
+if (!profile) {
+	if (options.profile == "default") {
+		console.log(markdownToConsoleText("You did not specify a profile, but a default profile does not exist. Use e.g. `slave --create-profile default openai gpt-6-luna` to create one."));
 	}
-	// Short flags can be combined (for example, -cw is equivalent to -c -w).
-	const flags = argument.startsWith("--") || argument.length <= 2
-		? [argument]
-		: [...argument.slice(1)].map((flag) => `-${flag}`);
-	for (const flag of flags) {
-		processFlag(flag);
+	else {
+		console.log(markdownToConsoleText(`No such profile. Use e.g. \`slave --create-profile ${options.profile} openai gpt-6-luna\` to create it.`));
 	}
+	process.exit(1);
+}
+
+let prompt = program.args.join(" ").trim();
+let previous_response_id;
+const overrides = [profile.provider.startsWith("http") ? `${profile.model} via ${profile.provider}` : `${profile.provider}/${profile.model}`];
+if (options.continue || options.cont) {
+	previous_response_id = state.previous_response_id;
+}
+else if (options.amend) {
+	previous_response_id = state.previous_previous_response_id;
+}
+if (options.web) {
+	tools.push({ type: "web_search" });
+	overrides.push("web search enabled");
+}
+if (options.fs == false || options.nofs) {
+	tools = tools.filter(tool => tool.type != "function");
+	overrides.push("no filesystem access");
 }
-let prompt = process.argv.slice(i).join(" ").trim();
 let stdinText = "";
 if (!process.stdin.isTTY) {
 	const chunks = [];
@@ -325,7 +377,7 @@ if (!process.stdin.isTTY) {
 	stdinText = Buffer.concat(chunks).toString("utf8");
 }
 if (!prompt) {
-	console.log("Syntax: slave [flags] [--] <prompt>");
+	console.log("No prompt given.");
 	process.exit(1);
 }
 
@@ -334,13 +386,23 @@ if (stdinText) {
 	overrides.push("stdin provided");
 	prompt = `${stdinText}\n\n${prompt}`;
 }
-if (overrides.length) {
-	console.log(`(${overrides.join(", ")})`);
+console.log(`(${overrides.join(", ")})\n`);
+
+//console.log({ model: profile.model, prompt, previous_response_id });
+
+const clientOpts = {
+	apiKey: state.apiKeys[profile.provider],
+};
+if (profile.provider != "openai") {
+	clientOpts.baseURL = profile.provider;
+	clientOpts.apiKey ||= "dummy";
 }
-console.log();
-const response = await generateResponseOptionallyUsingTools(prompt, previous_response_id);
-fs.writeFileSync(path.join(configDir, ".state.json"), JSON.stringify({ previous_response_id: response.id }), "utf8");
+const client = new OpenAI(clientOpts);
+const response = await generateResponseOptionallyUsingTools(client, profile.model, prompt, previous_response_id);
+state.previous_previous_response_id = previous_response_id;
+state.previous_response_id = response.id;
+saveState();
 if (response.used_tools) {
 	console.log();
 }
-console.log(markdownToConsoleText(response.output_text).trimEnd() + "\n");
+console.log(markdownToConsoleText(response.output_text) + "\n");

package/package.json

@@ -4,12 +4,13 @@
 		"type": "git",
 		"url": "git+https://github.com/calamity-inc/slave.git"
 	},
-	"version": "0.1.0",
+	"version": "0.2.0",
 	"type": "module",
 	"bin": {
-		"slave": "./index.js"
+		"slave": "index.js"
 	},
 	"dependencies": {
+		"commander": "^15.0.0",
 		"ignore": "^7.0.13",
 		"marked": "^12",
 		"marked-terminal": "7.0.0",