@gguf/coder 0.3.0 → 0.3.1

package/source/custom-commands/executor.ts

@@ -0,0 +1,64 @@
+import {substituteTemplateVariables} from '@/custom-commands/parser';
+import type {CustomCommand} from '@/types/index';
+
+export class CustomCommandExecutor {
+	/**
+	 * Execute a custom command with given arguments
+	 */
+	execute(command: CustomCommand, args: string[]): string {
+		// Build template variables from parameters and arguments
+		const variables: Record<string, string> = {};
+
+		if (command.metadata.parameters && command.metadata.parameters.length > 0) {
+			// Map arguments to parameters
+			command.metadata.parameters.forEach((param: string, index: number) => {
+				variables[param] = args[index] || '';
+			});
+
+			// Also provide all args as a single variable
+			variables['args'] = args.join(' ');
+		}
+
+		// Add some default context variables
+		variables['cwd'] = process.cwd();
+		variables['command'] = command.fullName;
+
+		// Substitute variables in the command content
+		const promptContent = substituteTemplateVariables(
+			command.content,
+			variables,
+		);
+
+		// Add a note about this being a custom command that can be improved
+		const fullPrompt = `[Executing custom command: /${command.fullName}]\n\n${promptContent}\n\n[Note: If this custom command could be improved, please provide feedback on how to enhance it.]`;
+
+		// Execute the prompt as if the user typed it
+		return fullPrompt;
+	}
+
+	/**
+	 * Format command help text
+	 */
+	formatHelp(command: CustomCommand): string {
+		const parts: string[] = [`/${command.fullName}`];
+
+		if (command.metadata.parameters && command.metadata.parameters.length > 0) {
+			parts.push(
+				command.metadata.parameters.map((p: string) => `<${p}>`).join(' '),
+			);
+		}
+
+		if (command.metadata.description) {
+			parts.push(`- ${command.metadata.description}`);
+		}
+
+		if (command.metadata.aliases && command.metadata.aliases.length > 0) {
+			const aliasNames = command.metadata.aliases.map((a: string) =>
+				command.namespace ? `${command.namespace}:${a}` : a,
+			);
+			parts.push(`(aliases: ${aliasNames.join(', ')})`);
+		}
+
+		return parts.join(' ');
+	}
+}

package/source/custom-commands/loader.spec.ts

@@ -0,0 +1,314 @@
+import { writeFileSync, rmSync, existsSync, mkdirSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import test from 'ava';
+import { CustomCommandLoader } from './loader';
+
+// Helper to create a valid custom command file
+function createCommandFile(path: string, content: string) {
+	const fullContent = `---
+description: ${content}
+---
+
+${content}`;
+	writeFileSync(path, fullContent, 'utf-8');
+}
+
+// Helper to create a unique test directory for each test
+function createTestDir(testName: string): string {
+	const dir = join(tmpdir(), `coder-cmd-test-${Date.now()}-${testName}`);
+	mkdirSync(dir, {recursive: true});
+	return dir;
+}
+
+// Helper to clean up test directory
+function cleanupTestDir(dir: string) {
+	if (existsSync(dir)) {
+		rmSync(dir, {recursive: true, force: true});
+	}
+}
+
+test('CustomCommandLoader - constructor initializes with project root', t => {
+	const testDir = createTestDir('constructor');
+	t.teardown(() => cleanupTestDir(testDir));
+
+	const loader = new CustomCommandLoader(testDir);
+	t.truthy(loader);
+});
+
+test('CustomCommandLoader - constructor uses cwd when no path provided', t => {
+	const loader = new CustomCommandLoader();
+	t.truthy(loader);
+});
+
+test('CustomCommandLoader - hasCustomCommands returns false when no commands directory', t => {
+	const testDir = createTestDir('has-no-commands');
+	t.teardown(() => cleanupTestDir(testDir));
+
+	const loader = new CustomCommandLoader(testDir);
+	t.false(loader.hasCustomCommands());
+});
+
+test('CustomCommandLoader - hasCustomCommands returns true when commands directory exists', t => {
+	const testDir = createTestDir('has-commands');
+	t.teardown(() => cleanupTestDir(testDir));
+
+	const commandsDir = join(testDir, '.coder', 'commands');
+	mkdirSync(commandsDir, {recursive: true});
+
+	const loader = new CustomCommandLoader(testDir);
+	t.true(loader.hasCustomCommands());
+});
+
+test('CustomCommandLoader - getCommandsDirectory returns correct path', t => {
+	const testDir = createTestDir('get-dir');
+	t.teardown(() => cleanupTestDir(testDir));
+
+	const loader = new CustomCommandLoader(testDir);
+	const expectedPath = join(testDir, '.coder', 'commands');
+	t.is(loader.getCommandsDirectory(), expectedPath);
+});
+
+test('CustomCommandLoader - loadCommands with no commands directory', t => {
+	const testDir = createTestDir('no-dir');
+	t.teardown(() => cleanupTestDir(testDir));
+
+	const loader = new CustomCommandLoader(testDir);
+	t.notThrows(() => loader.loadCommands());
+
+	const commands = loader.getAllCommands();
+	t.is(commands.length, 0);
+});
+
+test('CustomCommandLoader - loadCommands loads single command', t => {
+	const testDir = createTestDir('single-cmd');
+	t.teardown(() => cleanupTestDir(testDir));
+
+	const commandsDir = join(testDir, '.coder', 'commands');
+	mkdirSync(commandsDir, {recursive: true});
+	createCommandFile(join(commandsDir, 'test.md'), 'A test command');
+
+	const loader = new CustomCommandLoader(testDir);
+	loader.loadCommands();
+
+	const commands = loader.getAllCommands();
+	t.is(commands.length, 1);
+	t.is(commands[0].name, 'test');
+});
+
+test('CustomCommandLoader - loadCommands loads multiple commands', t => {
+	const testDir = createTestDir('multi-cmd');
+	t.teardown(() => cleanupTestDir(testDir));
+
+	const commandsDir = join(testDir, '.coder', 'commands');
+	mkdirSync(commandsDir, {recursive: true});
+	createCommandFile(join(commandsDir, 'cmd1.md'), 'Command 1');
+	createCommandFile(join(commandsDir, 'cmd2.md'), 'Command 2');
+	createCommandFile(join(commandsDir, 'cmd3.md'), 'Command 3');
+
+	const loader = new CustomCommandLoader(testDir);
+	loader.loadCommands();
+
+	const commands = loader.getAllCommands();
+	t.is(commands.length, 3);
+});
+
+test('CustomCommandLoader - loadCommands loads namespaced commands', t => {
+	const testDir = createTestDir('namespace');
+	t.teardown(() => cleanupTestDir(testDir));
+
+	const commandsDir = join(testDir, '.coder', 'commands');
+	const namespaceDir = join(commandsDir, 'git');
+	mkdirSync(namespaceDir, {recursive: true});
+	createCommandFile(join(namespaceDir, 'commit.md'), 'Git commit command');
+
+	const loader = new CustomCommandLoader(testDir);
+	loader.loadCommands();
+
+	const command = loader.getCommand('git:commit');
+	t.truthy(command);
+	t.is(command?.name, 'commit');
+	t.is(command?.namespace, 'git');
+	t.is(command?.fullName, 'git:commit');
+});
+
+test('CustomCommandLoader - getCommand retrieves command by name', t => {
+	const testDir = createTestDir('get-cmd');
+	t.teardown(() => cleanupTestDir(testDir));
+
+	const commandsDir = join(testDir, '.coder', 'commands');
+	mkdirSync(commandsDir, {recursive: true});
+	createCommandFile(join(commandsDir, 'test.md'), 'Test command');
+
+	const loader = new CustomCommandLoader(testDir);
+	loader.loadCommands();
+
+	const command = loader.getCommand('test');
+	t.truthy(command);
+	t.is(command?.name, 'test');
+});
+
+test('CustomCommandLoader - getCommand returns undefined for non-existent command', t => {
+	const testDir = createTestDir('get-nonexistent');
+	t.teardown(() => cleanupTestDir(testDir));
+
+	const loader = new CustomCommandLoader(testDir);
+	loader.loadCommands();
+
+	const command = loader.getCommand('nonexistent');
+	t.is(command, undefined);
+});
+
+test('CustomCommandLoader - getAllCommands returns array', t => {
+	const testDir = createTestDir('get-all');
+	t.teardown(() => cleanupTestDir(testDir));
+
+	const commandsDir = join(testDir, '.coder', 'commands');
+	mkdirSync(commandsDir, {recursive: true});
+	createCommandFile(join(commandsDir, 'test.md'), 'Test command');
+
+	const loader = new CustomCommandLoader(testDir);
+	loader.loadCommands();
+
+	const commands = loader.getAllCommands();
+	t.true(Array.isArray(commands));
+	t.is(commands.length, 1);
+});
+
+test('CustomCommandLoader - getSuggestions returns matching commands', t => {
+	const testDir = createTestDir('suggestions');
+	t.teardown(() => cleanupTestDir(testDir));
+
+	const commandsDir = join(testDir, '.coder', 'commands');
+	mkdirSync(commandsDir, {recursive: true});
+	createCommandFile(join(commandsDir, 'test1.md'), 'Test 1');
+	createCommandFile(join(commandsDir, 'test2.md'), 'Test 2');
+	createCommandFile(join(commandsDir, 'other.md'), 'Other');
+
+	const loader = new CustomCommandLoader(testDir);
+	loader.loadCommands();
+
+	const suggestions = loader.getSuggestions('test');
+
+	t.true(suggestions.includes('test1'));
+	t.true(suggestions.includes('test2'));
+	t.false(suggestions.includes('other'));
+});
+
+test('CustomCommandLoader - getSuggestions is case insensitive', t => {
+	const testDir = createTestDir('case-insensitive');
+	t.teardown(() => cleanupTestDir(testDir));
+
+	const commandsDir = join(testDir, '.coder', 'commands');
+	mkdirSync(commandsDir, {recursive: true});
+	createCommandFile(join(commandsDir, 'MyCommand.md'), 'My command');
+
+	const loader = new CustomCommandLoader(testDir);
+	loader.loadCommands();
+
+	const suggestionsLower = loader.getSuggestions('mycommand');
+	const suggestionsUpper = loader.getSuggestions('MYCOMMAND');
+
+	t.true(suggestionsLower.includes('MyCommand'));
+	t.true(suggestionsUpper.includes('MyCommand'));
+});
+
+test('CustomCommandLoader - getSuggestions returns empty array when no matches', t => {
+	const testDir = createTestDir('no-matches');
+	t.teardown(() => cleanupTestDir(testDir));
+
+	const loader = new CustomCommandLoader(testDir);
+	loader.loadCommands();
+
+	const suggestions = loader.getSuggestions('nonexistent');
+	t.deepEqual(suggestions, []);
+});
+
+test('CustomCommandLoader - loadCommands clears existing commands', t => {
+	const testDir = createTestDir('clears');
+	t.teardown(() => cleanupTestDir(testDir));
+
+	const commandsDir = join(testDir, '.coder', 'commands');
+	mkdirSync(commandsDir, {recursive: true});
+	createCommandFile(join(commandsDir, 'test.md'), 'Test');
+
+	const loader = new CustomCommandLoader(testDir);
+	loader.loadCommands();
+	t.is(loader.getAllCommands().length, 1);
+
+	// Reload
+	loader.loadCommands();
+	t.is(loader.getAllCommands().length, 1);
+});
+
+test('CustomCommandLoader - loadCommands handles invalid command files gracefully', t => {
+	const testDir = createTestDir('invalid');
+	t.teardown(() => cleanupTestDir(testDir));
+
+	const commandsDir = join(testDir, '.coder', 'commands');
+	mkdirSync(commandsDir, {recursive: true});
+
+	// Create invalid file (no frontmatter)
+	writeFileSync(join(commandsDir, 'invalid.md'), 'Just content without frontmatter', 'utf-8');
+
+	// Create valid file
+	createCommandFile(join(commandsDir, 'valid.md'), 'Valid command');
+
+	const loader = new CustomCommandLoader(testDir);
+	t.notThrows(() => loader.loadCommands());
+
+	// Should still load the valid command
+	const commands = loader.getAllCommands();
+	t.true(commands.some(c => c.name === 'valid'));
+});
+
+test('CustomCommandLoader - handles deeply nested namespaces', t => {
+	const testDir = createTestDir('nested');
+	t.teardown(() => cleanupTestDir(testDir));
+
+	const commandsDir = join(testDir, '.coder', 'commands');
+	const deepDir = join(commandsDir, 'level1', 'level2', 'level3');
+	mkdirSync(deepDir, {recursive: true});
+	createCommandFile(join(deepDir, 'deep.md'), 'Deep command');
+
+	const loader = new CustomCommandLoader(testDir);
+	loader.loadCommands();
+
+	const command = loader.getCommand('level1:level2:level3:deep');
+	t.truthy(command);
+	t.is(command?.fullName, 'level1:level2:level3:deep');
+});
+
+test('CustomCommandLoader - ignores non-markdown files', t => {
+	const testDir = createTestDir('ignore-non-md');
+	t.teardown(() => cleanupTestDir(testDir));
+
+	const commandsDir = join(testDir, '.coder', 'commands');
+	mkdirSync(commandsDir, {recursive: true});
+	createCommandFile(join(commandsDir, 'test.md'), 'Test command');
+	writeFileSync(join(commandsDir, 'test.txt'), 'Not a command', 'utf-8');
+	writeFileSync(join(commandsDir, 'test.js'), 'console.log("test");', 'utf-8');
+
+	const loader = new CustomCommandLoader(testDir);
+	loader.loadCommands();
+
+	// Should only load the .md file
+	t.is(loader.getAllCommands().length, 1);
+});
+
+test('CustomCommandLoader - loadCommands clears aliases on reload', t => {
+	const testDir = createTestDir('clear-aliases');
+	t.teardown(() => cleanupTestDir(testDir));
+
+	const commandsDir = join(testDir, '.coder', 'commands');
+	mkdirSync(commandsDir, {recursive: true});
+	createCommandFile(join(commandsDir, 'test.md'), 'Test');
+
+	const loader = new CustomCommandLoader(testDir);
+	loader.loadCommands();
+	t.is(loader.getAllCommands().length, 1);
+
+	// Reload
+	loader.loadCommands();
+	t.is(loader.getAllCommands().length, 1);
+});

package/source/custom-commands/loader.ts

@@ -0,0 +1,153 @@
+import {existsSync, readdirSync, statSync} from 'fs';
+import {basename, join} from 'path';
+import {parseCommandFile} from '@/custom-commands/parser';
+import type {CustomCommand} from '@/types/index';
+import {logError} from '@/utils/message-queue';
+
+export class CustomCommandLoader {
+	private commands: Map<string, CustomCommand> = new Map();
+	private aliases: Map<string, string> = new Map(); // alias -> command name
+	private projectRoot: string;
+	private commandsDir: string;
+
+	constructor(projectRoot: string = process.cwd()) {
+		this.projectRoot = projectRoot;
+		// nosemgrep
+		this.commandsDir = join(projectRoot, '.coder', 'commands'); // nosemgrep
+	}
+
+	/**
+	 * Load all custom commands from the .coder/commands directory
+	 */
+	loadCommands(): void {
+		this.commands.clear();
+		this.aliases.clear();
+
+		if (!existsSync(this.commandsDir)) {
+			return; // No custom commands directory
+		}
+
+		this.scanDirectory(this.commandsDir);
+	}
+
+	/**
+	 * Recursively scan directory for .md files
+	 */
+	private scanDirectory(dir: string, namespace?: string): void {
+		const entries = readdirSync(dir);
+
+		for (const entry of entries) {
+			const fullPath = join(dir, entry); // nosemgrep
+			const stat = statSync(fullPath);
+
+			if (stat.isDirectory()) {
+				// Subdirectory becomes a namespace
+				const subNamespace = namespace ? `${namespace}:${entry}` : entry;
+				this.scanDirectory(fullPath, subNamespace);
+			} else if (entry.endsWith('.md')) {
+				// Parse and register command
+				this.loadCommand(fullPath, namespace);
+			}
+		}
+	}
+
+	/**
+	 * Load a single command file
+	 */
+	private loadCommand(filePath: string, namespace?: string): void {
+		try {
+			const parsed = parseCommandFile(filePath);
+			const commandName = basename(filePath, '.md');
+			const fullName = namespace ? `${namespace}:${commandName}` : commandName;
+
+			const command: CustomCommand = {
+				name: commandName,
+				path: filePath,
+				namespace,
+				fullName,
+				metadata: parsed.metadata,
+				content: parsed.content,
+			};
+
+			// Register main command
+			this.commands.set(fullName, command);
+
+			// Register aliases
+			if (parsed.metadata.aliases) {
+				for (const alias of parsed.metadata.aliases) {
+					const fullAlias = namespace ? `${namespace}:${alias}` : alias;
+					this.aliases.set(fullAlias, fullName);
+				}
+			}
+		} catch (error) {
+			logError(
+				`Failed to load custom command from ${filePath}: ${String(error)}`,
+			);
+		}
+	}
+
+	/**
+	 * Get a command by name (checking aliases too)
+	 */
+	getCommand(name: string): CustomCommand | undefined {
+		// Check direct command name
+		const command = this.commands.get(name);
+		if (command) return command;
+
+		// Check aliases
+		const aliasTarget = this.aliases.get(name);
+		if (aliasTarget) {
+			return this.commands.get(aliasTarget);
+		}
+
+		return undefined;
+	}
+
+	/**
+	 * Get all available commands
+	 */
+	getAllCommands(): CustomCommand[] {
+		return Array.from(this.commands.values());
+	}
+
+	/**
+	 * Get command suggestions for autocomplete
+	 */
+	getSuggestions(prefix: string): string[] {
+		const suggestions: string[] = [];
+		const lowerPrefix = prefix.toLowerCase();
+
+		// Add matching command names
+		for (const [name, _command] of this.commands.entries()) {
+			if (name.toLowerCase().startsWith(lowerPrefix)) {
+				suggestions.push(name);
+			}
+		}
+
+		// Add matching aliases
+		for (const [alias, _target] of this.aliases.entries()) {
+			if (
+				alias.toLowerCase().startsWith(lowerPrefix) &&
+				!suggestions.includes(alias)
+			) {
+				suggestions.push(alias);
+			}
+		}
+
+		return suggestions.sort();
+	}
+
+	/**
+	 * Check if commands directory exists
+	 */
+	hasCustomCommands(): boolean {
+		return existsSync(this.commandsDir);
+	}
+
+	/**
+	 * Get the commands directory path
+	 */
+	getCommandsDirectory(): string {
+		return this.commandsDir;
+	}
+}