Bohdan Triapitsyn
0adcba854b
- Introduced command scope types (user and project) to manage command configurations at different levels. - Enhanced command management functions to check and create commands based on their scope. - Updated the API to handle command creation, updates, and deletions with respect to their scope. - Added a reload button in the AboutSettings component to refresh OpenCode configuration. - Improved command source retrieval to prioritize project-level commands over user-level commands. - Refactored related functions to ensure proper handling of command paths and configurations based on scope.
609 lines
17 KiB
JavaScript
609 lines
17 KiB
JavaScript
import fs from 'fs';
|
|
import path from 'path';
|
|
import os from 'os';
|
|
import yaml from 'yaml';
|
|
import stripJsonComments from 'strip-json-comments';
|
|
|
|
const OPENCODE_CONFIG_DIR = path.join(os.homedir(), '.config', 'opencode');
|
|
const AGENT_DIR = path.join(OPENCODE_CONFIG_DIR, 'agent');
|
|
const COMMAND_DIR = path.join(OPENCODE_CONFIG_DIR, 'command');
|
|
const CONFIG_FILE = path.join(OPENCODE_CONFIG_DIR, 'opencode.json');
|
|
const PROMPT_FILE_PATTERN = /^\{file:(.+)\}$/i;
|
|
|
|
// Command scope types
|
|
const COMMAND_SCOPE = {
|
|
USER: 'user',
|
|
PROJECT: 'project'
|
|
};
|
|
|
|
function ensureDirs() {
|
|
if (!fs.existsSync(OPENCODE_CONFIG_DIR)) {
|
|
fs.mkdirSync(OPENCODE_CONFIG_DIR, { recursive: true });
|
|
}
|
|
if (!fs.existsSync(AGENT_DIR)) {
|
|
fs.mkdirSync(AGENT_DIR, { recursive: true });
|
|
}
|
|
if (!fs.existsSync(COMMAND_DIR)) {
|
|
fs.mkdirSync(COMMAND_DIR, { recursive: true });
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Ensure project-level command directory exists
|
|
*/
|
|
function ensureProjectCommandDir(workingDirectory) {
|
|
const projectCommandDir = path.join(workingDirectory, '.opencode', 'command');
|
|
if (!fs.existsSync(projectCommandDir)) {
|
|
fs.mkdirSync(projectCommandDir, { recursive: true });
|
|
}
|
|
return projectCommandDir;
|
|
}
|
|
|
|
/**
|
|
* Get project-level command path
|
|
*/
|
|
function getProjectCommandPath(workingDirectory, commandName) {
|
|
return path.join(workingDirectory, '.opencode', 'command', `${commandName}.md`);
|
|
}
|
|
|
|
/**
|
|
* Get user-level command path
|
|
*/
|
|
function getUserCommandPath(commandName) {
|
|
return path.join(COMMAND_DIR, `${commandName}.md`);
|
|
}
|
|
|
|
/**
|
|
* Determine command scope based on where the .md file exists
|
|
* Priority: project level > user level > null (built-in only)
|
|
*/
|
|
function getCommandScope(commandName, workingDirectory) {
|
|
if (workingDirectory) {
|
|
const projectPath = getProjectCommandPath(workingDirectory, commandName);
|
|
if (fs.existsSync(projectPath)) {
|
|
return { scope: COMMAND_SCOPE.PROJECT, path: projectPath };
|
|
}
|
|
}
|
|
|
|
const userPath = getUserCommandPath(commandName);
|
|
if (fs.existsSync(userPath)) {
|
|
return { scope: COMMAND_SCOPE.USER, path: userPath };
|
|
}
|
|
|
|
return { scope: null, path: null };
|
|
}
|
|
|
|
/**
|
|
* Get the path where a command should be written based on scope
|
|
*/
|
|
function getCommandWritePath(commandName, workingDirectory, requestedScope) {
|
|
// For updates: check existing location first (project takes precedence)
|
|
const existing = getCommandScope(commandName, workingDirectory);
|
|
if (existing.path) {
|
|
return existing;
|
|
}
|
|
|
|
// For new commands or built-in overrides: use requested scope or default to user
|
|
const scope = requestedScope || COMMAND_SCOPE.USER;
|
|
if (scope === COMMAND_SCOPE.PROJECT && workingDirectory) {
|
|
return {
|
|
scope: COMMAND_SCOPE.PROJECT,
|
|
path: getProjectCommandPath(workingDirectory, commandName)
|
|
};
|
|
}
|
|
|
|
return {
|
|
scope: COMMAND_SCOPE.USER,
|
|
path: getUserCommandPath(commandName)
|
|
};
|
|
}
|
|
|
|
function isPromptFileReference(value) {
|
|
if (typeof value !== 'string') {
|
|
return false;
|
|
}
|
|
return PROMPT_FILE_PATTERN.test(value.trim());
|
|
}
|
|
|
|
function resolvePromptFilePath(reference) {
|
|
const match = typeof reference === 'string' ? reference.trim().match(PROMPT_FILE_PATTERN) : null;
|
|
if (!match) {
|
|
return null;
|
|
}
|
|
let target = match[1].trim();
|
|
if (!target) {
|
|
return null;
|
|
}
|
|
|
|
if (target.startsWith('./')) {
|
|
target = target.slice(2);
|
|
target = path.join(OPENCODE_CONFIG_DIR, target);
|
|
} else if (!path.isAbsolute(target)) {
|
|
target = path.join(OPENCODE_CONFIG_DIR, target);
|
|
}
|
|
|
|
return target;
|
|
}
|
|
|
|
function writePromptFile(filePath, content) {
|
|
const dir = path.dirname(filePath);
|
|
fs.mkdirSync(dir, { recursive: true });
|
|
fs.writeFileSync(filePath, content ?? '', 'utf8');
|
|
console.log(`Updated prompt file: ${filePath}`);
|
|
}
|
|
|
|
function readConfig() {
|
|
if (!fs.existsSync(CONFIG_FILE)) {
|
|
return {};
|
|
}
|
|
try {
|
|
const content = fs.readFileSync(CONFIG_FILE, 'utf8');
|
|
const normalized = stripJsonComments(content).trim();
|
|
if (!normalized) {
|
|
return {};
|
|
}
|
|
return JSON.parse(normalized);
|
|
} catch (error) {
|
|
console.error('Failed to read config file:', error);
|
|
throw new Error('Failed to read OpenCode configuration');
|
|
}
|
|
}
|
|
|
|
function writeConfig(config) {
|
|
try {
|
|
|
|
if (fs.existsSync(CONFIG_FILE)) {
|
|
const backupFile = `${CONFIG_FILE}.openchamber.backup`;
|
|
fs.copyFileSync(CONFIG_FILE, backupFile);
|
|
console.log(`Created config backup: ${backupFile}`);
|
|
}
|
|
|
|
fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf8');
|
|
console.log('Successfully wrote config file');
|
|
} catch (error) {
|
|
console.error('Failed to write config file:', error);
|
|
throw new Error('Failed to write OpenCode configuration');
|
|
}
|
|
}
|
|
|
|
function parseMdFile(filePath) {
|
|
try {
|
|
const content = fs.readFileSync(filePath, 'utf8');
|
|
const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
|
|
|
|
if (!match) {
|
|
return { frontmatter: {}, body: content.trim() };
|
|
}
|
|
|
|
const frontmatter = yaml.parse(match[1]) || {};
|
|
const body = match[2].trim();
|
|
|
|
return { frontmatter, body };
|
|
} catch (error) {
|
|
console.error(`Failed to parse markdown file ${filePath}:`, error);
|
|
throw new Error('Failed to parse agent markdown file');
|
|
}
|
|
}
|
|
|
|
function writeMdFile(filePath, frontmatter, body) {
|
|
try {
|
|
// Filter out null/undefined values - OpenCode expects keys to be omitted rather than set to null
|
|
const cleanedFrontmatter = Object.fromEntries(
|
|
Object.entries(frontmatter).filter(([, value]) => value != null)
|
|
);
|
|
const yamlStr = yaml.stringify(cleanedFrontmatter);
|
|
const content = `---\n${yamlStr}---\n\n${body}`;
|
|
fs.writeFileSync(filePath, content, 'utf8');
|
|
console.log(`Successfully wrote markdown file: ${filePath}`);
|
|
} catch (error) {
|
|
console.error(`Failed to write markdown file ${filePath}:`, error);
|
|
throw new Error('Failed to write agent markdown file');
|
|
}
|
|
}
|
|
|
|
function getAgentSources(agentName) {
|
|
const mdPath = path.join(AGENT_DIR, `${agentName}.md`);
|
|
const mdExists = fs.existsSync(mdPath);
|
|
|
|
const config = readConfig();
|
|
const jsonSection = config.agent?.[agentName];
|
|
|
|
const sources = {
|
|
md: {
|
|
exists: mdExists,
|
|
path: mdExists ? mdPath : null,
|
|
fields: []
|
|
},
|
|
json: {
|
|
exists: !!jsonSection,
|
|
path: CONFIG_FILE,
|
|
fields: []
|
|
}
|
|
};
|
|
|
|
if (mdExists) {
|
|
const { frontmatter, body } = parseMdFile(mdPath);
|
|
sources.md.fields = Object.keys(frontmatter);
|
|
if (body) {
|
|
sources.md.fields.push('prompt');
|
|
}
|
|
}
|
|
|
|
if (jsonSection) {
|
|
sources.json.fields = Object.keys(jsonSection);
|
|
}
|
|
|
|
return sources;
|
|
}
|
|
|
|
function createAgent(agentName, config) {
|
|
ensureDirs();
|
|
|
|
const mdPath = path.join(AGENT_DIR, `${agentName}.md`);
|
|
|
|
if (fs.existsSync(mdPath)) {
|
|
throw new Error(`Agent ${agentName} already exists as .md file`);
|
|
}
|
|
|
|
const existingConfig = readConfig();
|
|
if (existingConfig.agent?.[agentName]) {
|
|
throw new Error(`Agent ${agentName} already exists in opencode.json`);
|
|
}
|
|
|
|
const { prompt, ...frontmatter } = config;
|
|
|
|
writeMdFile(mdPath, frontmatter, prompt || '');
|
|
console.log(`Created new agent: ${agentName}`);
|
|
}
|
|
|
|
function updateAgent(agentName, updates) {
|
|
ensureDirs();
|
|
|
|
const mdPath = path.join(AGENT_DIR, `${agentName}.md`);
|
|
const mdExists = fs.existsSync(mdPath);
|
|
|
|
let mdData = mdExists ? parseMdFile(mdPath) : null;
|
|
let config = readConfig();
|
|
const jsonSection = config.agent?.[agentName];
|
|
|
|
let mdModified = false;
|
|
let jsonModified = false;
|
|
|
|
for (const [field, value] of Object.entries(updates)) {
|
|
|
|
if (field === 'prompt') {
|
|
const normalizedValue = typeof value === 'string' ? value : (value == null ? '' : String(value));
|
|
|
|
if (mdExists) {
|
|
mdData.body = normalizedValue;
|
|
mdModified = true;
|
|
} else if (isPromptFileReference(jsonSection?.prompt)) {
|
|
const promptFilePath = resolvePromptFilePath(jsonSection.prompt);
|
|
if (!promptFilePath) {
|
|
throw new Error(`Invalid prompt file reference for agent ${agentName}`);
|
|
}
|
|
writePromptFile(promptFilePath, normalizedValue);
|
|
} else if (isPromptFileReference(normalizedValue)) {
|
|
if (!config.agent) config.agent = {};
|
|
if (!config.agent[agentName]) config.agent[agentName] = {};
|
|
config.agent[agentName].prompt = normalizedValue;
|
|
jsonModified = true;
|
|
} else {
|
|
if (!config.agent) config.agent = {};
|
|
if (!config.agent[agentName]) config.agent[agentName] = {};
|
|
config.agent[agentName].prompt = normalizedValue;
|
|
jsonModified = true;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
const inMd = mdData?.frontmatter?.[field] !== undefined;
|
|
const inJson = jsonSection?.[field] !== undefined;
|
|
|
|
if (inMd) {
|
|
|
|
mdData.frontmatter[field] = value;
|
|
mdModified = true;
|
|
} else if (inJson) {
|
|
|
|
if (!config.agent) config.agent = {};
|
|
if (!config.agent[agentName]) config.agent[agentName] = {};
|
|
config.agent[agentName][field] = value;
|
|
jsonModified = true;
|
|
} else {
|
|
|
|
if (mdExists && jsonSection) {
|
|
|
|
if (!config.agent) config.agent = {};
|
|
if (!config.agent[agentName]) config.agent[agentName] = {};
|
|
config.agent[agentName][field] = value;
|
|
jsonModified = true;
|
|
} else if (mdExists) {
|
|
|
|
mdData.frontmatter[field] = value;
|
|
mdModified = true;
|
|
} else {
|
|
|
|
if (!config.agent) config.agent = {};
|
|
if (!config.agent[agentName]) config.agent[agentName] = {};
|
|
config.agent[agentName][field] = value;
|
|
jsonModified = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mdModified) {
|
|
writeMdFile(mdPath, mdData.frontmatter, mdData.body);
|
|
}
|
|
|
|
if (jsonModified) {
|
|
writeConfig(config);
|
|
}
|
|
|
|
console.log(`Updated agent: ${agentName} (md: ${mdModified}, json: ${jsonModified})`);
|
|
}
|
|
|
|
function deleteAgent(agentName) {
|
|
const mdPath = path.join(AGENT_DIR, `${agentName}.md`);
|
|
let deleted = false;
|
|
|
|
if (fs.existsSync(mdPath)) {
|
|
fs.unlinkSync(mdPath);
|
|
console.log(`Deleted agent .md file: ${mdPath}`);
|
|
deleted = true;
|
|
}
|
|
|
|
const config = readConfig();
|
|
if (config.agent?.[agentName]) {
|
|
delete config.agent[agentName];
|
|
writeConfig(config);
|
|
console.log(`Removed agent from opencode.json: ${agentName}`);
|
|
deleted = true;
|
|
}
|
|
|
|
if (!deleted) {
|
|
if (!config.agent) config.agent = {};
|
|
config.agent[agentName] = { disable: true };
|
|
writeConfig(config);
|
|
console.log(`Disabled built-in agent: ${agentName}`);
|
|
}
|
|
}
|
|
|
|
function getCommandSources(commandName, workingDirectory) {
|
|
// Check project level first (takes precedence)
|
|
const projectPath = workingDirectory ? getProjectCommandPath(workingDirectory, commandName) : null;
|
|
const projectExists = projectPath && fs.existsSync(projectPath);
|
|
|
|
// Then check user level
|
|
const userPath = getUserCommandPath(commandName);
|
|
const userExists = fs.existsSync(userPath);
|
|
|
|
// Determine which md file to use (project takes precedence)
|
|
const mdPath = projectExists ? projectPath : (userExists ? userPath : null);
|
|
const mdExists = !!mdPath;
|
|
const mdScope = projectExists ? COMMAND_SCOPE.PROJECT : (userExists ? COMMAND_SCOPE.USER : null);
|
|
|
|
const config = readConfig();
|
|
const jsonSection = config.command?.[commandName];
|
|
|
|
const sources = {
|
|
md: {
|
|
exists: mdExists,
|
|
path: mdPath,
|
|
scope: mdScope,
|
|
fields: []
|
|
},
|
|
json: {
|
|
exists: !!jsonSection,
|
|
path: CONFIG_FILE,
|
|
fields: []
|
|
},
|
|
// Additional info about both levels
|
|
projectMd: {
|
|
exists: projectExists,
|
|
path: projectPath
|
|
},
|
|
userMd: {
|
|
exists: userExists,
|
|
path: userPath
|
|
}
|
|
};
|
|
|
|
if (mdExists) {
|
|
const { frontmatter, body } = parseMdFile(mdPath);
|
|
sources.md.fields = Object.keys(frontmatter);
|
|
if (body) {
|
|
sources.md.fields.push('template');
|
|
}
|
|
}
|
|
|
|
if (jsonSection) {
|
|
sources.json.fields = Object.keys(jsonSection);
|
|
}
|
|
|
|
return sources;
|
|
}
|
|
|
|
function createCommand(commandName, config, workingDirectory, scope) {
|
|
ensureDirs();
|
|
|
|
// Check if command already exists at either level
|
|
const projectPath = workingDirectory ? getProjectCommandPath(workingDirectory, commandName) : null;
|
|
const userPath = getUserCommandPath(commandName);
|
|
|
|
if (projectPath && fs.existsSync(projectPath)) {
|
|
throw new Error(`Command ${commandName} already exists as project-level .md file`);
|
|
}
|
|
|
|
if (fs.existsSync(userPath)) {
|
|
throw new Error(`Command ${commandName} already exists as user-level .md file`);
|
|
}
|
|
|
|
const existingConfig = readConfig();
|
|
if (existingConfig.command?.[commandName]) {
|
|
throw new Error(`Command ${commandName} already exists in opencode.json`);
|
|
}
|
|
|
|
// Determine target path based on requested scope
|
|
let targetPath;
|
|
let targetScope;
|
|
|
|
if (scope === COMMAND_SCOPE.PROJECT && workingDirectory) {
|
|
ensureProjectCommandDir(workingDirectory);
|
|
targetPath = projectPath;
|
|
targetScope = COMMAND_SCOPE.PROJECT;
|
|
} else {
|
|
targetPath = userPath;
|
|
targetScope = COMMAND_SCOPE.USER;
|
|
}
|
|
|
|
// Extract scope from config - it's only used for path determination, not written to file
|
|
const { template, scope: _scopeFromConfig, ...frontmatter } = config;
|
|
|
|
writeMdFile(targetPath, frontmatter, template || '');
|
|
console.log(`Created new command: ${commandName} (scope: ${targetScope}, path: ${targetPath})`);
|
|
}
|
|
|
|
function updateCommand(commandName, updates, workingDirectory) {
|
|
ensureDirs();
|
|
|
|
// Determine correct path: project level takes precedence
|
|
const { scope, path: mdPath } = getCommandWritePath(commandName, workingDirectory);
|
|
const mdExists = mdPath && fs.existsSync(mdPath);
|
|
|
|
// If no existing md file, we need to create one (for built-in command overrides)
|
|
// Default to user level for built-in overrides
|
|
let targetPath = mdPath;
|
|
let targetScope = scope;
|
|
|
|
if (!mdExists) {
|
|
// No existing md file - this is a built-in override, create at user level
|
|
targetPath = getUserCommandPath(commandName);
|
|
targetScope = COMMAND_SCOPE.USER;
|
|
}
|
|
|
|
let mdData = mdExists ? parseMdFile(mdPath) : { frontmatter: {}, body: '' };
|
|
let config = readConfig();
|
|
const jsonSection = config.command?.[commandName];
|
|
|
|
let mdModified = false;
|
|
let jsonModified = false;
|
|
let creatingNewMd = !mdExists;
|
|
|
|
for (const [field, value] of Object.entries(updates)) {
|
|
|
|
if (field === 'template') {
|
|
const normalizedValue = typeof value === 'string' ? value : (value == null ? '' : String(value));
|
|
|
|
if (mdExists || creatingNewMd) {
|
|
mdData.body = normalizedValue;
|
|
mdModified = true;
|
|
} else if (isPromptFileReference(jsonSection?.template)) {
|
|
const templateFilePath = resolvePromptFilePath(jsonSection.template);
|
|
if (!templateFilePath) {
|
|
throw new Error(`Invalid template file reference for command ${commandName}`);
|
|
}
|
|
writePromptFile(templateFilePath, normalizedValue);
|
|
} else if (isPromptFileReference(normalizedValue)) {
|
|
if (!config.command) config.command = {};
|
|
if (!config.command[commandName]) config.command[commandName] = {};
|
|
config.command[commandName].template = normalizedValue;
|
|
jsonModified = true;
|
|
} else {
|
|
// Create new md file for the update
|
|
mdData.body = normalizedValue;
|
|
mdModified = true;
|
|
creatingNewMd = true;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
const inMd = mdData?.frontmatter?.[field] !== undefined;
|
|
const inJson = jsonSection?.[field] !== undefined;
|
|
|
|
if (inMd || creatingNewMd) {
|
|
mdData.frontmatter[field] = value;
|
|
mdModified = true;
|
|
} else if (inJson) {
|
|
if (!config.command) config.command = {};
|
|
if (!config.command[commandName]) config.command[commandName] = {};
|
|
config.command[commandName][field] = value;
|
|
jsonModified = true;
|
|
} else {
|
|
// New field - add to md if it exists or we're creating one
|
|
if (mdExists || creatingNewMd) {
|
|
mdData.frontmatter[field] = value;
|
|
mdModified = true;
|
|
} else {
|
|
if (!config.command) config.command = {};
|
|
if (!config.command[commandName]) config.command[commandName] = {};
|
|
config.command[commandName][field] = value;
|
|
jsonModified = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mdModified) {
|
|
writeMdFile(targetPath, mdData.frontmatter, mdData.body);
|
|
}
|
|
|
|
if (jsonModified) {
|
|
writeConfig(config);
|
|
}
|
|
|
|
console.log(`Updated command: ${commandName} (scope: ${targetScope}, md: ${mdModified}, json: ${jsonModified})`);
|
|
}
|
|
|
|
function deleteCommand(commandName, workingDirectory) {
|
|
let deleted = false;
|
|
|
|
// Check project level first (takes precedence)
|
|
if (workingDirectory) {
|
|
const projectPath = getProjectCommandPath(workingDirectory, commandName);
|
|
if (fs.existsSync(projectPath)) {
|
|
fs.unlinkSync(projectPath);
|
|
console.log(`Deleted project-level command .md file: ${projectPath}`);
|
|
deleted = true;
|
|
}
|
|
}
|
|
|
|
// Then check user level
|
|
const userPath = getUserCommandPath(commandName);
|
|
if (fs.existsSync(userPath)) {
|
|
fs.unlinkSync(userPath);
|
|
console.log(`Deleted user-level command .md file: ${userPath}`);
|
|
deleted = true;
|
|
}
|
|
|
|
// Also check json config
|
|
const config = readConfig();
|
|
if (config.command?.[commandName]) {
|
|
delete config.command[commandName];
|
|
writeConfig(config);
|
|
console.log(`Removed command from opencode.json: ${commandName}`);
|
|
deleted = true;
|
|
}
|
|
|
|
if (!deleted) {
|
|
throw new Error(`Command "${commandName}" not found`);
|
|
}
|
|
}
|
|
|
|
export {
|
|
getAgentSources,
|
|
createAgent,
|
|
updateAgent,
|
|
deleteAgent,
|
|
getCommandSources,
|
|
getCommandScope,
|
|
createCommand,
|
|
updateCommand,
|
|
deleteCommand,
|
|
readConfig,
|
|
writeConfig,
|
|
AGENT_DIR,
|
|
COMMAND_DIR,
|
|
CONFIG_FILE,
|
|
COMMAND_SCOPE
|
|
};
|