@calamity-inc/slave 0.3.2 → 0.4.1

package/src/log.js

@@ -0,0 +1,38 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { logDir } = require("./paths.js");
+
+const rotateLogs = () => {
+	const cutoff = Date.now() - 30 * 24 * 60 * 60 * 1000; // 30 days
+	for (const name of fs.readdirSync(logDir)) {
+		try {
+			if (fs.statSync(path.join(logDir, name)).mtimeMs < cutoff) {
+				fs.unlinkSync(path.join(logDir, name));
+			}
+		}
+		catch (e) {
+			// another process may have removed it already; ignore.
+		}
+	}
+};
+
+let logFh;
+const logWrite = (line) => {
+	if (!logFh) {
+		const now = new Date();
+		const pad = (n) => String(n).padStart(2, '0');
+		const logfileName = `${now.getUTCFullYear()}-${pad(now.getUTCMonth() + 1)}-${pad(now.getUTCDate())}T${pad(now.getUTCHours())}-${pad(now.getUTCMinutes())}-${pad(now.getUTCSeconds())}Z.txt`;
+		fs.mkdirSync(logDir, { recursive: true });
+		logFh = fs.openSync(path.join(logDir, logfileName), "a", 0o600);
+		rotateLogs();
+	}
+	fs.writeSync(logFh, line + "\n");
+};
+const logWriteBoth = (line) => {
+	console.log(line);
+	logWrite(line);
+};
+
+module.exports = { logWrite, logWriteBoth };

package/src/main.js

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+"use strict";
+
+async function main() {
+	const { Command } = require("commander");
+
+	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("-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("-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")
+		.option("--update-profile <name> <provider> <model>", "update a profile")
+		.option("--set-default", "set default profile")
+		.option("--list-profiles", "list all profiles")
+		.option("--delete-profile <name>", "delete a profile")
+		.option("--update-api-key <provider>", "update an API key")
+		.option("--logs", "get info about logs")
+		.option("--skills", "get info about skills")
+		.helpOption("-?, --help", "display help")
+		.parse();
+	const options = program.opts();
+
+	const { state, promptForApiKey, saveState, profileToString } = require("./state.js");
+
+	if (options.createProfile || options.updateProfile) {
+		if (!program.args[0] || !program.args[1]) {
+			console.error("Syntax: slave --create-profile <name> <provider> <model>");
+			process.exit(1);
+		}
+		const provider = program.args[0];
+		if (provider != "openai" && provider != "anthropic" && !provider.startsWith("http://") && !provider.startsWith("https://")) {
+			console.error(`Invalid provider: ${provider}`);
+			process.exit(1);
+		}
+		const name = options.createProfile || options.updateProfile;
+		if (Object.hasOwn(state.profiles, name)) {
+			if (options.createProfile) {
+				console.error("Profile already exists. Did you mean --update-profile?");
+				process.exit(1);
+			}
+		}
+		else {
+			if (options.updateProfile) {
+				console.error("No such profile. Did you mean --create-profile?");
+				process.exit(1);
+			}
+		}
+		state.profiles[name] = { provider, model: program.args[1] };
+		if (options.setDefault) {
+			state.defaultProfile = name;
+		}
+		if (!state.apiKeys[provider]) {
+			await promptForApiKey(provider);
+		}
+		saveState();
+		console.log(`${options.createProfile ? "Created" : "Updated"} ${name} profile${options.setDefault ? " and set as your default" : ""}.`);
+		process.exit(0);
+	}
+	if (options.setDefault) {
+		if (!program.args[0]) {
+			console.error("No profile name given.");
+			process.exit(1);
+		}
+		state.defaultProfile = program.args[0];
+		saveState();
+		console.log(`Set ${program.args[0]} as your default profile.`);
+		process.exit(0);
+	}
+	if (options.listProfiles) {
+		const names = Object.keys(state.profiles);
+		if (names.length == 0) {
+			console.log("No profiles.");
+		}
+		for (const name of names) {
+			if (state.defaultProfile == name) {
+				console.log(`${name} (default): ${profileToString(state.profiles[name])}`);
+			}
+			else {
+				console.log(`${name}: ${profileToString(state.profiles[name])}`);
+			}
+		}
+		process.exit(0);
+	}
+	if (options.deleteProfile) {
+		if (Object.hasOwn(state.profiles, options.deleteProfile)) {
+			delete state.profiles[options.deleteProfile];
+			saveState();
+			console.log(`Deleted ${options.deleteProfile} profile.`);
+		}
+		else {
+			console.log("No such profile.");
+		}
+		process.exit(0);
+	}
+	if (options.updateApiKey) {
+		await promptForApiKey(options.updateApiKey);
+		saveState();
+		console.log("Saved.");
+		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.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);
+	}
+
+	const { markdownToConsoleText } = require("./markdown.js");
+
+	const profile = state.profiles[options.profile ?? state.defaultProfile];
+	if (!profile) {
+		if (Object.keys(state.profiles).length == 0) {
+			console.error(markdownToConsoleText("You don't have any profiles. Use e.g. `slave --create-profile luna openai gpt-6-luna --set-default` to create one."));
+		}
+		else if (options.profile) {
+			console.error(markdownToConsoleText(`No such profile. Use e.g. \`slave --create-profile ${options.profile} openai gpt-6-luna\` to create it.`));
+		}
+		else {
+			console.error(markdownToConsoleText(`You did not specify a profile and no profile is set as your default. Use e.g. \`slave --set-default ${Object.keys(state.profiles)[0]}\` to set **${Object.keys(state.profiles)[0]}** as your default profile.`));
+		}
+		process.exit(1);
+	}
+
+	let prompt = program.args.join(" ").trim();
+	if (!prompt) {
+		console.error("No prompt given.");
+		process.exit(1);
+	}
+
+	const { execFileSync } = require("node:child_process");
+
+	const { default: Anthropic } = require("@anthropic-ai/sdk");
+	const { default: OpenAI } = require("openai");
+
+	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)];
+	state.providerStates[profile.provider] ??= {};
+	if (options.continue || options.cont) {
+		previous_provider_state = state.providerStates[profile.provider].previous;
+		setSandboxName(state.providerStates[profile.provider].sandbox_name);
+	}
+	else if (options.amend) {
+		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);
+	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) {
+		overrides.push("no 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");
+	}
+	logWriteBoth(`(${overrides.join(", ")})\n`);
+
+	//console.log({ model: profile.model, prompt, previous_provider_state });
+
+	const clientOpts = {
+		apiKey: state.apiKeys[profile.provider],
+	};
+	let response;
+	if (profile.provider == "anthropic") {
+		const client = new Anthropic(clientOpts);
+		response = await anthropic_generateResponseOptionallyUsingTools(client, profile.model, prompt, previous_provider_state);
+	}
+	else {
+		if (profile.provider != "openai") {
+			clientOpts.baseURL = profile.provider;
+			clientOpts.apiKey ||= "dummy";
+		}
+		const client = new OpenAI(clientOpts);
+		response = await openai_generateResponseOptionallyUsingTools(client, profile.model, prompt, previous_provider_state);
+	}
+	state.providerStates[profile.provider].previous_previous = previous_provider_state;
+	state.providerStates[profile.provider].previous = response.state;
+	if (state.providerStates[profile.provider].sandbox_name && state.providerStates[profile.provider].sandbox_name != getSandboxName()) {
+		execFileSync("docker", ["rm", "-f", state.providerStates[profile.provider].sandbox_name], { encoding: "utf8" });
+	}
+	state.providerStates[profile.provider].sandbox_name = getSandboxName();
+	saveState();
+	if (response.used_tools) {
+		logWriteBoth("");
+	}
+	console.log(markdownToConsoleText(response.output_text) + "\n");
+	logWrite(response.output_text);
+}
+
+main().catch((err) => {
+	console.error(err);
+	process.exit(1);
+});

package/src/markdown.js

@@ -0,0 +1,13 @@
+const { marked } = require("marked");
+const { markedTerminal } = require("marked-terminal");
+
+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).trimEnd() + "\n";
+	console.error = _console_error;
+	return text;
+};
+
+module.exports = { markdownToConsoleText };

package/src/paths.js

@@ -0,0 +1,9 @@
+"use strict";
+
+const envPaths = require("env-paths").default;
+
+const { data, log } = envPaths("slave");
+module.exports = {
+	configDir: data,
+	logDir: log,
+};

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

@@ -0,0 +1,33 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+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")) : {};
+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 });
+	try {
+		state.apiKeys[provider] = (await readline.question("Enter your API key: ")).trim();
+	}
+	finally {
+		readline.close();
+	}
+};
+
+const saveState = () => {
+	fs.mkdirSync(configDir, { recursive: true });
+	fs.writeFileSync(path.join(configDir, "state.json"), JSON.stringify(state, null, 2), { encoding: "utf8", mode: 0o600 });
+};
+
+const profileToString = (profile) => {
+	return profile.provider.startsWith("http") ? `${profile.model} via ${profile.provider}` : `${profile.provider}/${profile.model}`;
+};
+
+module.exports = { state, promptForApiKey, saveState, profileToString };