mirror of
https://github.com/glittercowboy/get-shit-done
synced 2026-04-26 09:45:22 +02:00
470 lines
15 KiB
JavaScript
470 lines
15 KiB
JavaScript
#!/usr/bin/env node
|
|
|
|
const fs = require("fs");
|
|
const path = require("path");
|
|
const os = require("os");
|
|
const readline = require("readline");
|
|
|
|
// Colors
|
|
const cyan = "\x1b[36m";
|
|
const green = "\x1b[32m";
|
|
const yellow = "\x1b[33m";
|
|
const dim = "\x1b[2m";
|
|
const reset = "\x1b[0m";
|
|
|
|
// Get version from package.json
|
|
const pkg = require("../package.json");
|
|
|
|
const banner = `
|
|
${cyan} ██████╗ ███████╗██████╗
|
|
██╔════╝ ██╔════╝██╔══██╗
|
|
██║ ███╗███████╗██║ ██║
|
|
██║ ██║╚════██║██║ ██║
|
|
╚██████╔╝███████║██████╔╝
|
|
╚═════╝ ╚══════╝╚═════╝${reset}
|
|
|
|
Get Shit Done ${dim}v${pkg.version}${reset}
|
|
A meta-prompting, context engineering and spec-driven
|
|
development system for OpenCode by TÂCHES.
|
|
`;
|
|
|
|
// Parse args
|
|
const args = process.argv.slice(2);
|
|
const hasGlobal = args.includes("--global") || args.includes("-g");
|
|
const hasLocal = args.includes("--local") || args.includes("-l");
|
|
|
|
// Parse --config-dir argument
|
|
function parseConfigDirArg() {
|
|
const configDirIndex = args.findIndex((arg) => arg === "--config-dir" || arg === "-c");
|
|
if (configDirIndex !== -1) {
|
|
const nextArg = args[configDirIndex + 1];
|
|
if (!nextArg || nextArg.startsWith("-")) {
|
|
console.error(` ${yellow}--config-dir requires a path argument${reset}`);
|
|
process.exit(1);
|
|
}
|
|
return nextArg;
|
|
}
|
|
const configDirArg = args.find((arg) => arg.startsWith("--config-dir=") || arg.startsWith("-c="));
|
|
if (configDirArg) {
|
|
return configDirArg.split("=")[1];
|
|
}
|
|
return null;
|
|
}
|
|
|
|
const explicitConfigDir = parseConfigDirArg();
|
|
const hasHelp = args.includes("--help") || args.includes("-h");
|
|
|
|
console.log(banner);
|
|
|
|
// Show help if requested
|
|
if (hasHelp) {
|
|
console.log(` ${yellow}Usage:${reset} npx get-shit-done-opencode [options]
|
|
|
|
${yellow}Options:${reset}
|
|
${cyan}-g, --global${reset} Install globally (to OpenCode config directory)
|
|
${cyan}-l, --local${reset} Install locally (to ./.opencode in current directory)
|
|
${cyan}-c, --config-dir <path>${reset} Specify custom OpenCode config directory
|
|
${cyan}-h, --help${reset} Show this help message
|
|
|
|
${yellow}Examples:${reset}
|
|
${dim}# Install to default ~/.config/opencode directory${reset}
|
|
npx get-shit-done-opencode --global
|
|
|
|
${dim}# Install to custom config directory${reset}
|
|
npx get-shit-done-opencode --global --config-dir ~/.config/opencode-alt
|
|
|
|
${dim}# Install to current project only${reset}
|
|
npx get-shit-done-opencode --local
|
|
`);
|
|
process.exit(0);
|
|
}
|
|
|
|
/**
|
|
* Expand ~ to home directory
|
|
*/
|
|
function expandTilde(filePath) {
|
|
if (filePath && filePath.startsWith("~/")) {
|
|
return path.join(os.homedir(), filePath.slice(2));
|
|
}
|
|
return filePath;
|
|
}
|
|
|
|
function resolveGsdRoot() {
|
|
try {
|
|
const gsdPkg = require.resolve("get-shit-done-cc/package.json");
|
|
return path.dirname(gsdPkg);
|
|
} catch (e) {
|
|
const localRoot = path.join(__dirname, "..", "..", "..");
|
|
if (fs.existsSync(path.join(localRoot, "commands"))) return localRoot;
|
|
}
|
|
console.error(` ${yellow}✗${reset} Failed to locate get-shit-done-cc assets`);
|
|
process.exit(1);
|
|
}
|
|
|
|
function transformHook(content) {
|
|
return content
|
|
.replace(/get-shit-done-cc/g, "get-shit-done-opencode")
|
|
.replace(/['"]\\.claude['"]/g, "'.config/opencode'");
|
|
}
|
|
|
|
function colorToHex(value) {
|
|
const normalized = value.trim().toLowerCase();
|
|
const map = {
|
|
green: "#22c55e",
|
|
blue: "#3b82f6",
|
|
purple: "#8b5cf6",
|
|
cyan: "#06b6d4",
|
|
yellow: "#f59e0b",
|
|
orange: "#f97316",
|
|
};
|
|
if (normalized.startsWith("#")) return normalized;
|
|
return map[normalized] || normalized;
|
|
}
|
|
|
|
function toolsLineToBlock(line) {
|
|
const raw = line.split(":").slice(1).join(":").trim();
|
|
if (!raw) return [line];
|
|
const tools = raw
|
|
.split(",")
|
|
.map((item) => item.trim())
|
|
.filter(Boolean)
|
|
.map((item) => item.toLowerCase());
|
|
const entries = tools.map((tool) => {
|
|
const key = /^[a-z0-9_]+$/.test(tool) ? tool : `"${tool}"`;
|
|
return ` ${key}: true`;
|
|
});
|
|
return ["tools:", ...entries];
|
|
}
|
|
|
|
function transformMarkdown(content, pathPrefix) {
|
|
return content
|
|
.replace(/~\/\.claude\//g, pathPrefix)
|
|
.replace(/\bgsd:([a-z0-9-]+)/g, "gsd/$1")
|
|
.replace(/npx get-shit-done-cc/g, "npx get-shit-done-opencode");
|
|
}
|
|
|
|
function transformAgentMarkdown(content, pathPrefix) {
|
|
const updated = transformMarkdown(content, pathPrefix);
|
|
const match = updated.match(/^---\r?\n([\s\S]*?)\r?\n---/);
|
|
if (!match) return updated;
|
|
|
|
const lines = match[1].split(/\r?\n/);
|
|
const out = [];
|
|
|
|
for (const line of lines) {
|
|
if (line.startsWith("tools:")) {
|
|
out.push(...toolsLineToBlock(line));
|
|
continue;
|
|
}
|
|
if (line.startsWith("color:")) {
|
|
const value = line.split(":").slice(1).join(":").trim();
|
|
const colorValue = colorToHex(value);
|
|
out.push(`color: "${colorValue}"`);
|
|
continue;
|
|
}
|
|
out.push(line);
|
|
}
|
|
|
|
return updated.replace(match[0], `---\n${out.join("\n")}\n---`);
|
|
}
|
|
|
|
/**
|
|
* Recursively copy directory, transforming markdown files
|
|
*/
|
|
function copyWithTransform(srcDir, destDir, pathPrefix) {
|
|
if (fs.existsSync(destDir)) {
|
|
fs.rmSync(destDir, { recursive: true });
|
|
}
|
|
fs.mkdirSync(destDir, { recursive: true });
|
|
|
|
const entries = fs.readdirSync(srcDir, { withFileTypes: true });
|
|
|
|
for (const entry of entries) {
|
|
const srcPath = path.join(srcDir, entry.name);
|
|
const destPath = path.join(destDir, entry.name);
|
|
|
|
if (entry.isDirectory()) {
|
|
copyWithTransform(srcPath, destPath, pathPrefix);
|
|
} else if (entry.name.endsWith(".md")) {
|
|
let content = fs.readFileSync(srcPath, "utf8");
|
|
content = transformMarkdown(content, pathPrefix);
|
|
fs.writeFileSync(destPath, content);
|
|
} else {
|
|
fs.copyFileSync(srcPath, destPath);
|
|
}
|
|
}
|
|
}
|
|
|
|
function copyCommands(srcDir, destRoot, pathPrefix) {
|
|
const destDir = path.join(destRoot, "commands", "gsd");
|
|
if (fs.existsSync(destDir)) {
|
|
fs.rmSync(destDir, { recursive: true });
|
|
}
|
|
fs.mkdirSync(destDir, { recursive: true });
|
|
const entries = fs.readdirSync(srcDir, { withFileTypes: true });
|
|
for (const entry of entries) {
|
|
if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
|
|
const srcPath = path.join(srcDir, entry.name);
|
|
const destPath = path.join(destDir, entry.name);
|
|
let content = fs.readFileSync(srcPath, "utf8");
|
|
content = transformMarkdown(content, pathPrefix);
|
|
fs.writeFileSync(destPath, content);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify a directory exists and contains files
|
|
*/
|
|
function verifyInstalled(dirPath, description) {
|
|
if (!fs.existsSync(dirPath)) {
|
|
console.error(` ${yellow}✗${reset} Failed to install ${description}: directory not created`);
|
|
return false;
|
|
}
|
|
try {
|
|
const entries = fs.readdirSync(dirPath);
|
|
if (entries.length === 0) {
|
|
console.error(` ${yellow}✗${reset} Failed to install ${description}: directory is empty`);
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
console.error(` ${yellow}✗${reset} Failed to install ${description}: ${e.message}`);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Verify a file exists
|
|
*/
|
|
function verifyFileInstalled(filePath, description) {
|
|
if (!fs.existsSync(filePath)) {
|
|
console.error(` ${yellow}✗${reset} Failed to install ${description}: file not created`);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function readConfig(configPath) {
|
|
if (!fs.existsSync(configPath)) return {};
|
|
try {
|
|
return JSON.parse(fs.readFileSync(configPath, "utf8"));
|
|
} catch (e) {
|
|
return {};
|
|
}
|
|
}
|
|
|
|
function writeConfig(configPath, config) {
|
|
fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
|
|
}
|
|
|
|
/**
|
|
* Install to the specified directory
|
|
*/
|
|
function install(isGlobal) {
|
|
const src = resolveGsdRoot();
|
|
const configDir = expandTilde(explicitConfigDir) || expandTilde(process.env.OPENCODE_CONFIG_DIR);
|
|
const defaultGlobalDir = configDir || path.join(os.homedir(), ".config", "opencode");
|
|
const opencodeDir = isGlobal ? defaultGlobalDir : path.join(process.cwd(), ".opencode");
|
|
|
|
const locationLabel = isGlobal
|
|
? opencodeDir.replace(os.homedir(), "~")
|
|
: opencodeDir.replace(process.cwd(), ".");
|
|
|
|
const pathPrefix = isGlobal ? (configDir ? `${opencodeDir}/` : "~/.config/opencode/") : "./.opencode/";
|
|
|
|
console.log(` Installing to ${cyan}${locationLabel}${reset}\n`);
|
|
|
|
const failures = [];
|
|
|
|
// Create commands directory and copy commands
|
|
const gsdCommandsSrc = path.join(src, "commands", "gsd");
|
|
if (fs.existsSync(gsdCommandsSrc)) {
|
|
copyCommands(gsdCommandsSrc, opencodeDir, pathPrefix);
|
|
const gsdCommandsDest = path.join(opencodeDir, "commands", "gsd");
|
|
if (verifyInstalled(gsdCommandsDest, "commands/gsd")) {
|
|
console.log(` ${green}✓${reset} Installed commands/gsd`);
|
|
} else {
|
|
failures.push("commands/gsd");
|
|
}
|
|
} else {
|
|
failures.push("commands/gsd");
|
|
}
|
|
|
|
// Copy get-shit-done assets with path replacement
|
|
const gsdSrc = path.join(src, "get-shit-done");
|
|
const gsdDest = path.join(opencodeDir, "get-shit-done");
|
|
copyWithTransform(gsdSrc, gsdDest, pathPrefix);
|
|
if (verifyInstalled(gsdDest, "get-shit-done")) {
|
|
console.log(` ${green}✓${reset} Installed get-shit-done`);
|
|
} else {
|
|
failures.push("get-shit-done");
|
|
}
|
|
|
|
// Copy agents to .opencode/agents (replace only gsd-*.md)
|
|
const agentsSrc = path.join(src, "agents");
|
|
if (fs.existsSync(agentsSrc)) {
|
|
const agentsDest = path.join(opencodeDir, "agents");
|
|
fs.mkdirSync(agentsDest, { recursive: true });
|
|
|
|
if (fs.existsSync(agentsDest)) {
|
|
for (const file of fs.readdirSync(agentsDest)) {
|
|
if (file.startsWith("gsd-") && file.endsWith(".md")) {
|
|
fs.unlinkSync(path.join(agentsDest, file));
|
|
}
|
|
}
|
|
}
|
|
|
|
const agentEntries = fs.readdirSync(agentsSrc, { withFileTypes: true });
|
|
for (const entry of agentEntries) {
|
|
if (entry.isFile() && entry.name.endsWith(".md")) {
|
|
let content = fs.readFileSync(path.join(agentsSrc, entry.name), "utf8");
|
|
content = transformAgentMarkdown(content, pathPrefix);
|
|
fs.writeFileSync(path.join(agentsDest, entry.name), content);
|
|
}
|
|
}
|
|
if (verifyInstalled(agentsDest, "agents")) {
|
|
console.log(` ${green}✓${reset} Installed agents`);
|
|
} else {
|
|
failures.push("agents");
|
|
}
|
|
}
|
|
|
|
// Copy CHANGELOG.md
|
|
const changelogSrc = path.join(src, "CHANGELOG.md");
|
|
const changelogDest = path.join(opencodeDir, "get-shit-done", "CHANGELOG.md");
|
|
if (fs.existsSync(changelogSrc)) {
|
|
fs.copyFileSync(changelogSrc, changelogDest);
|
|
if (verifyFileInstalled(changelogDest, "CHANGELOG.md")) {
|
|
console.log(` ${green}✓${reset} Installed CHANGELOG.md`);
|
|
} else {
|
|
failures.push("CHANGELOG.md");
|
|
}
|
|
}
|
|
|
|
// Write VERSION file
|
|
const versionDest = path.join(opencodeDir, "get-shit-done", "VERSION");
|
|
fs.writeFileSync(versionDest, pkg.version);
|
|
if (verifyFileInstalled(versionDest, "VERSION")) {
|
|
console.log(` ${green}✓${reset} Wrote VERSION (${pkg.version})`);
|
|
} else {
|
|
failures.push("VERSION");
|
|
}
|
|
|
|
// Copy update hook and configure opencode.json
|
|
const hookSrc = path.join(src, "hooks", "gsd-check-update.js");
|
|
const hookDestDir = path.join(opencodeDir, "get-shit-done", "hooks");
|
|
const hookDest = path.join(hookDestDir, "gsd-check-update.js");
|
|
fs.mkdirSync(hookDestDir, { recursive: true });
|
|
if (fs.existsSync(hookSrc)) {
|
|
let content = fs.readFileSync(hookSrc, "utf8");
|
|
content = transformHook(content);
|
|
fs.writeFileSync(hookDest, content);
|
|
if (verifyFileInstalled(hookDest, "get-shit-done/hooks/gsd-check-update.js")) {
|
|
console.log(` ${green}✓${reset} Installed update hook`);
|
|
} else {
|
|
failures.push("get-shit-done/hooks/gsd-check-update.js");
|
|
}
|
|
} else {
|
|
failures.push("get-shit-done/hooks/gsd-check-update.js");
|
|
}
|
|
|
|
const configPath = path.join(opencodeDir, "opencode.json");
|
|
const config = readConfig(configPath);
|
|
if (!config.experimental) config.experimental = {};
|
|
if (!config.experimental.hook) config.experimental.hook = {};
|
|
if (!config.experimental.hook.session_completed) {
|
|
config.experimental.hook.session_completed = [];
|
|
}
|
|
|
|
const hookCommand = ["node", hookDest];
|
|
const hasHook = config.experimental.hook.session_completed.some(
|
|
(entry) =>
|
|
Array.isArray(entry.command) &&
|
|
entry.command.length === hookCommand.length &&
|
|
entry.command.every((value, idx) => value === hookCommand[idx]),
|
|
);
|
|
if (!hasHook) {
|
|
config.experimental.hook.session_completed.push({ command: hookCommand });
|
|
writeConfig(configPath, config);
|
|
console.log(` ${green}✓${reset} Configured update hook in opencode.json`);
|
|
}
|
|
|
|
if (failures.length > 0) {
|
|
console.error(`\n ${yellow}Installation incomplete!${reset} Failed: ${failures.join(", ")}`);
|
|
console.error(
|
|
` Try running directly: node ~/.npm/_npx/*/node_modules/get-shit-done-opencode/bin/install.js --global\n`,
|
|
);
|
|
process.exit(1);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prompt for install location
|
|
*/
|
|
function promptLocation() {
|
|
if (!process.stdin.isTTY) {
|
|
console.log(` ${yellow}Non-interactive terminal detected, defaulting to global install${reset}\n`);
|
|
install(true);
|
|
finishInstall();
|
|
return;
|
|
}
|
|
|
|
const rl = readline.createInterface({
|
|
input: process.stdin,
|
|
output: process.stdout,
|
|
});
|
|
|
|
let answered = false;
|
|
|
|
rl.on("close", () => {
|
|
if (!answered) {
|
|
answered = true;
|
|
console.log(`\n ${yellow}Input stream closed, defaulting to global install${reset}\n`);
|
|
install(true);
|
|
finishInstall();
|
|
}
|
|
});
|
|
|
|
const configDir = expandTilde(explicitConfigDir) || expandTilde(process.env.OPENCODE_CONFIG_DIR);
|
|
const globalPath = configDir || path.join(os.homedir(), ".config", "opencode");
|
|
const globalLabel = globalPath.replace(os.homedir(), "~");
|
|
|
|
console.log(` ${yellow}Where would you like to install?${reset}
|
|
|
|
${cyan}1${reset}) Global ${dim}(${globalLabel})${reset} - available in all projects
|
|
${cyan}2${reset}) Local ${dim}(./.opencode)${reset} - this project only
|
|
`);
|
|
|
|
rl.question(` Choice ${dim}[1]${reset}: `, (answer) => {
|
|
answered = true;
|
|
rl.close();
|
|
const choice = answer.trim() || "1";
|
|
const isGlobal = choice !== "2";
|
|
install(isGlobal);
|
|
finishInstall();
|
|
});
|
|
}
|
|
|
|
function finishInstall() {
|
|
console.log(`
|
|
${green}Done!${reset} Open OpenCode and run ${cyan}gsd/help${reset}.
|
|
`);
|
|
}
|
|
|
|
// Main
|
|
if (hasGlobal && hasLocal) {
|
|
console.error(` ${yellow}Cannot specify both --global and --local${reset}`);
|
|
process.exit(1);
|
|
} else if (explicitConfigDir && hasLocal) {
|
|
console.error(` ${yellow}Cannot use --config-dir with --local${reset}`);
|
|
process.exit(1);
|
|
} else if (hasGlobal) {
|
|
install(true);
|
|
finishInstall();
|
|
} else if (hasLocal) {
|
|
install(false);
|
|
finishInstall();
|
|
} else {
|
|
promptLocation();
|
|
}
|