@indiccoder/mentis-cli 1.0.9 → 1.1.1

package/dist/utils/ProjectInitializer.js

@@ -0,0 +1,181 @@
+"use strict";
+/**
+ * ProjectInitializer - Initialize project with .mentis.md
+ * Interactive wizard for creating project guide files
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectInitializer = void 0;
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class ProjectInitializer {
+    /**
+     * Run the interactive project initialization wizard
+     */
+    async run(cwd = process.cwd()) {
+        console.log('\n📁 Initialize Project with .mentis.md\n');
+        // Step 1: Project name
+        const { projectName } = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'projectName',
+                message: 'Project name:',
+                default: path.basename(cwd)
+            }
+        ]);
+        // Step 2: Project description
+        const { description } = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'description',
+                message: 'Brief description:',
+                default: 'A software project'
+            }
+        ]);
+        // Step 3: Tech stack
+        const { techStack } = await inquirer_1.default.prompt([
+            {
+                type: 'checkbox',
+                name: 'techStack',
+                message: 'Select technologies:',
+                choices: [
+                    'TypeScript',
+                    'JavaScript',
+                    'Python',
+                    'React',
+                    'Vue',
+                    'Node.js',
+                    'Express',
+                    'PostgreSQL',
+                    'MongoDB',
+                    'Redis',
+                    'Docker',
+                    'GraphQL',
+                    'REST API',
+                    'Other'
+                ]
+            }
+        ]);
+        // Step 4: Project type
+        const { projectType } = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'projectType',
+                message: 'Project type:',
+                choices: ['Web Application', 'API/Backend', 'CLI Tool', 'Library/Package', 'Mobile App', 'Desktop App', 'Other']
+            }
+        ]);
+        // Step 5: Conventions
+        const { useConventions } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'useConventions',
+                message: 'Add coding conventions?',
+                default: true
+            }
+        ]);
+        let conventions = '';
+        if (useConventions) {
+            const { conventionStyle } = await inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'conventionStyle',
+                    message: 'Style guide:',
+                    choices: ['Standard', 'Airbnb', 'Google', 'Prettier', 'Custom']
+                }
+            ]);
+            conventions = this.getConventionText(conventionStyle);
+        }
+        // Create .mentis.md content
+        const content = this.generateMentisMd({
+            projectName,
+            description,
+            techStack,
+            projectType,
+            conventions
+        });
+        // Write to file
+        const mentisMdPath = path.join(cwd, '.mentis.md');
+        fs.writeFileSync(mentisMdPath, content, 'utf-8');
+        console.log(chalk_1.default.green(`\n✓ Created .mentis.md`));
+        console.log(chalk_1.default.dim(`\nTip: Edit .mentis.md to add project-specific instructions for Mentis.\n`));
+        return true;
+    }
+    /**
+     * Generate .mentis.md content
+     */
+    generateMentisMd(options) {
+        const { projectName, description, techStack, projectType, conventions } = options;
+        let content = `# ${projectName}\n\n`;
+        content += `${description}\n\n`;
+        content += `**Type**: ${projectType}\n\n`;
+        content += `## Tech Stack\n\n`;
+        content += techStack.map(t => `- ${t}`).join('\n');
+        content += `\n\n`;
+        if (conventions) {
+            content += `## Coding Conventions\n\n`;
+            content += `${conventions}\n\n`;
+        }
+        content += `## Project Structure\n\n`;
+        content += `<!-- Add project structure here -->\n\n`;
+        content += `## Guidelines for Mentis\n\n`;
+        content += `- When writing code, follow the conventions above\n`;
+        content += `- Prefer existing patterns in the codebase\n`;
+        content += `- Add comments for complex logic\n`;
+        content += `- Run tests before suggesting changes\n\n`;
+        content += `## Common Commands\n\n`;
+        content += `<!-- Add common development commands here -->\n`;
+        return content;
+    }
+    /**
+     * Get convention text based on style
+     */
+    getConventionText(style) {
+        const conventions = {
+            'Standard': `- Use 2 spaces for indentation\n- Use camelCase for variables\n- Use PascalCase for classes\n- Prefer const over let\n- Use arrow functions`,
+            'Airbnb': `- Follow Airbnb Style Guide\n- Use 2 spaces for indentation\n- Prefer named exports\n- Use template literals`,
+            'Google': `- Follow Google JavaScript Style Guide\n- Use 2 spaces for indentation\n- JSDoc comments for functions`,
+            'Prettier': `- Use Prettier for formatting\n- 2 spaces for indentation\n- Single quotes for strings\n- No trailing commas`,
+            'Custom': `- Define your conventions below`
+        };
+        return conventions[style] || conventions['Standard'];
+    }
+}
+exports.ProjectInitializer = ProjectInitializer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indiccoder/mentis-cli",
-  "version": "1.0.9",
+  "version": "1.1.1",
   "publishConfig": {
     "access": "public"
   },
@@ -61,4 +61,4 @@
     "@types/node": "^25.0.2",
     "typescript": "^5.9.3"
   }
-}
+}

package/src/commands/Command.ts

@@ -0,0 +1,40 @@
+/**
+ * Custom Slash Commands System
+ * Users can define their own slash commands as markdown files
+ */
+
+export interface CommandFrontmatter {
+    description?: string;
+    'allowed-tools'?: string[];
+    'argument-hint'?: string;
+    model?: string;
+    'disable-model-invocation'?: boolean;
+}
+
+export interface Command {
+    name: string;              // Command name (from filename)
+    type: 'personal' | 'project';  // Personal or project command
+    path: string;               // Path to command file
+    directory: string;          // Directory containing the command
+    frontmatter: CommandFrontmatter;
+    content: string;            // Command content (markdown)
+    description: string;        // Command description
+    hasParameters: boolean;     // Whether command uses parameters
+}
+
+export interface CommandExecutionContext {
+    command: Command;
+    args: string[];             // Command arguments
+    substitutePlaceholders: (content: string, args: string[]) => string;
+    executeBash: (bashCommand: string) => Promise<string>;
+    readFile: (filePath: string) => Promise<string>;
+}
+
+/**
+ * Parsed command with substitutions applied
+ */
+export interface ParsedCommand {
+    content: string;            // Content with substitutions applied
+    bashCommands: string[];     // Bash commands to execute
+    fileReferences: string[];   // Files to read
+}

package/src/commands/CommandCreator.ts

@@ -0,0 +1,281 @@
+/**
+ * CommandCreator - Interactive wizard for creating new custom slash commands
+ */
+
+import inquirer from 'inquirer';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { CommandManager } from './CommandManager';
+
+export class CommandCreator {
+    private commandManager: CommandManager;
+
+    constructor(commandManager?: CommandManager) {
+        this.commandManager = commandManager || new CommandManager();
+    }
+
+    /**
+     * Run the interactive command creation wizard
+     */
+    async run(name?: string): Promise<boolean> {
+        console.log('\n📝 Create a new Custom Slash Command\n');
+
+        let commandName: string;
+        let commandType: 'personal' | 'project';
+        let description: string;
+        let allowedTools: string[] | undefined;
+        let argumentHint: string | undefined;
+        let namespace: string | undefined;
+
+        // Step 1: Command Name
+        if (name) {
+            commandName = name;
+        } else {
+            const { name: inputName } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'name',
+                    message: 'Command name (lowercase, numbers, hyphens only):',
+                    validate: (input: string) => {
+                        if (!input) return 'Name is required';
+                        if (!/^[a-z0-9-]+$/.test(input)) {
+                            return 'Name must contain only lowercase letters, numbers, and hyphens';
+                        }
+                        if (input.length > 64) return 'Name must be 64 characters or less';
+                        return true;
+                    }
+                }
+            ]);
+            commandName = inputName;
+        }
+
+        // Step 2: Command Type
+        const { type } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'type',
+                message: 'Command type:',
+                choices: [
+                    { name: 'Personal (available in all projects)', value: 'personal' },
+                    { name: 'Project (shared with team via git)', value: 'project' }
+                ],
+                default: 'personal'
+            }
+        ]);
+        commandType = type;
+
+        // Step 3: Namespace (optional, for grouping)
+        const { useNamespace } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'useNamespace',
+                message: 'Add a namespace for grouping?',
+                default: false
+            }
+        ]);
+
+        if (useNamespace) {
+            const { ns } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'ns',
+                    message: 'Namespace (e.g., "git", "review", "test"):',
+                    validate: (input: string) => {
+                        if (!input) return 'Namespace is required';
+                        if (!/^[a-z0-9-]+$/.test(input)) {
+                            return 'Namespace must contain only lowercase letters, numbers, and hyphens';
+                        }
+                        return true;
+                    }
+                }
+            ]);
+            namespace = ns;
+        }
+
+        // Step 4: Description
+        const { desc } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'desc',
+                message: 'Description:',
+                validate: (input: string) => {
+                    if (!input) return 'Description is required';
+                    if (input.length > 1024) return 'Description must be 1024 characters or less';
+                    return true;
+                }
+            }
+        ]);
+        description = desc;
+
+        // Step 5: Arguments (optional)
+        const { useArgs } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'useArgs',
+                message: 'Does this command accept arguments?',
+                default: false
+            }
+        ]);
+
+        if (useArgs) {
+            const { hint } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'hint',
+                    message: 'Argument hint (e.g., "<file>", "[options]"):',
+                    validate: (input: string) => {
+                        if (!input) return 'Argument hint is required';
+                        return true;
+                    }
+                }
+            ]);
+            argumentHint = hint;
+        }
+
+        // Step 6: Allowed Tools (optional)
+        const { useAllowedTools } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'useAllowedTools',
+                message: 'Restrict which tools this command can use?',
+                default: false
+            }
+        ]);
+
+        if (useAllowedTools) {
+            const { tools } = await inquirer.prompt([
+                {
+                    type: 'checkbox',
+                    name: 'tools',
+                    message: 'Select allowed tools:',
+                    choices: [
+                        { name: 'Read (read_file)', value: 'Read' },
+                        { name: 'Write (write_file)', value: 'Write' },
+                        { name: 'Edit (edit_file)', value: 'Edit' },
+                        { name: 'Grep (search files)', value: 'Grep' },
+                        { name: 'Glob (find files)', value: 'Glob' },
+                        { name: 'ListDir (list directory)', value: 'ListDir' },
+                        { name: 'SearchFile (search in files)', value: 'SearchFile' },
+                        { name: 'RunShell (run shell command)', value: 'RunShell' },
+                        { name: 'WebSearch (web search)', value: 'WebSearch' },
+                        { name: 'GitStatus', value: 'GitStatus' },
+                        { name: 'GitDiff', value: 'GitDiff' },
+                        { name: 'GitCommit', value: 'GitCommit' },
+                        { name: 'GitPush', value: 'GitPush' },
+                        { name: 'GitPull', value: 'GitPull' }
+                    ]
+                }
+            ]);
+            allowedTools = tools.length > 0 ? tools : undefined;
+        }
+
+        // Step 7: Create the command
+        return this.createCommand(commandName, commandType, description, allowedTools, argumentHint, namespace);
+    }
+
+    /**
+     * Create the command file
+     */
+    async createCommand(
+        name: string,
+        type: 'personal' | 'project',
+        description: string,
+        allowedTools?: string[],
+        argumentHint?: string,
+        namespace?: string
+    ): Promise<boolean> {
+        const baseDir = type === 'personal'
+            ? path.join(os.homedir(), '.mentis', 'commands')
+            : path.join(process.cwd(), '.mentis', 'commands');
+
+        const commandDir = namespace ? path.join(baseDir, namespace) : baseDir;
+        const commandFile = path.join(commandDir, `${name}.md`);
+
+        // Check if command already exists
+        if (fs.existsSync(commandFile)) {
+            const { overwrite } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'overwrite',
+                    message: `Command "${name}" already exists. Overwrite?`,
+                    default: false
+                }
+            ]);
+
+            if (!overwrite) {
+                console.log('Cancelled.');
+                return false;
+            }
+        }
+
+        // Create directory
+        if (!fs.existsSync(commandDir)) {
+            fs.mkdirSync(commandDir, { recursive: true });
+        }
+
+        // Generate command content
+        let content = `---\ndescription: ${description}\n`;
+
+        if (allowedTools && allowedTools.length > 0) {
+            content += `allowed-tools: [${allowedTools.map(t => `"${t}"`).join(', ')}]\n`;
+        }
+
+        if (argumentHint) {
+            content += `argument-hint: "${argumentHint}"\n`;
+        }
+
+        content += `---\n\n`;
+
+        // Add usage instructions in markdown
+        content += `## Usage\n\n`;
+        content += `Use this command by typing: /${name}${argumentHint ? ` ${argumentHint}` : ''}\n\n`;
+        content += `## Instructions\n\n`;
+        content += `Add your instructions here. You can use:\n`;
+        content += `- \`$1\`, \`$2\`, etc. for positional arguments\n`;
+        content += `- \`$ARGUMENTS\` for all arguments\n`;
+        content += `- \`\!\\\`command\`\` for bash commands\n`;
+        content += `- \`@file\` for file references\n\n`;
+
+        // Write command file
+        fs.writeFileSync(commandFile, content, 'utf-8');
+
+        console.log(`\n✓ Command created at: ${commandFile}`);
+        console.log(`\nNext steps:`);
+        console.log(`  1. Edit ${commandFile} to add instructions`);
+        console.log(`  2. Restart Mentis or use /commands validate to load the new command`);
+
+        return true;
+    }
+}
+
+/**
+ * Validate commands and show results
+ */
+export async function validateCommands(commandManager: CommandManager): Promise<void> {
+    const commands = commandManager.getAllCommands();
+
+    console.log('\n📋 Command Validation Results\n');
+
+    if (commands.length === 0) {
+        console.log('No custom commands to validate.');
+        console.log('Create commands with: /commands create');
+        return;
+    }
+
+    for (const cmd of commands) {
+        const isValid = cmd.name && cmd.name.length > 0 && cmd.content.length > 0;
+        const icon = isValid ? '✓' : '✗';
+        console.log(`${icon} /${cmd.name} (${cmd.type})`);
+
+        if (!isValid) {
+            console.log(`  ERROR: Invalid command structure`);
+        }
+
+        if (cmd.frontmatter['allowed-tools'] && cmd.frontmatter['allowed-tools'].length > 0) {
+            console.log(`  Allowed tools: ${cmd.frontmatter['allowed-tools'].join(', ')}`);
+        }
+    }
+
+    console.log(`\n✓ Validated ${commands.length} commands`);
+}