@indiccoder/mentis-cli 1.0.8 → 1.1.0

package/examples/skills/commit-helper/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: commit-helper
+description: Generates clear, conventional commit messages from git diffs. Use when writing commit messages, reviewing staged changes, or when the user asks for help with git commits.
+allowed-tools: ["GitStatus", "GitDiff", "GitCommit"]
+---
+
+# Commit Message Helper
+
+This skill helps you write clear, informative git commit messages following conventional commit format.
+
+## Instructions
+
+When the user wants to commit changes:
+
+1. **Check git status** to see what files are staged
+2. **Review the diff** to understand what changed
+3. **Generate a commit message** with:
+   - **Type**: One of `feat`, `fix`, `docs`, `style`, `refactor`, `test`, `chore`
+   - **Scope**: (optional) The component or module affected
+   - **Summary**: Brief description under 50 characters
+   - **Body**: Detailed explanation of what and why (not how)
+   - **Footer**: (optional) Breaking changes or references
+
+## Commit Types
+
+| Type | Description |
+|------|-------------|
+| `feat` | New feature |
+| `fix` | Bug fix |
+| `docs` | Documentation changes |
+| `style` | Code style changes (formatting, etc.) |
+| `refactor` | Code refactoring |
+| `test` | Adding or updating tests |
+| `chore` | Maintenance tasks |
+
+## Examples
+
+### Feature Addition
+```
+feat(api): add user authentication endpoint
+
+Add OAuth2 authentication for the REST API.
+Implements login, logout, and token refresh.
+```
+
+### Bug Fix
+```
+fix(cli): prevent crash when config file is missing
+
+Check for config file existence before reading.
+Show helpful error message if file not found.
+```
+
+### Documentation
+```
+docs: update README with new installation instructions
+
+Clarify NPM installation steps and add troubleshooting section.
+```
+
+## Best Practices
+
+- Use present tense ("add" not "added")
+- Explain what and why, not how
+- Keep summary under 50 characters
+- Reference issues in footer: `Closes #123`

package/examples/skills/pdf-processing/SKILL.md

@@ -0,0 +1,108 @@
+---
+name: pdf-processing
+description: Extract text, fill forms, merge PDFs, and manipulate PDF documents. Use when working with PDF files, forms, or document extraction. Requires pdf-parse package.
+---
+
+# PDF Processing
+
+This skill provides PDF manipulation capabilities for text extraction, form filling, and document operations.
+
+## Prerequisites
+
+Install required packages:
+```bash
+npm install pdf-parse
+# or
+pnpm add pdf-parse
+# or
+yarn add pdf-parse
+```
+
+## Capabilities
+
+### 1. Text Extraction
+Extract plain text from PDF files with page-by-page information.
+
+### 2. Form Field Detection
+Identify and extract form fields from PDF documents.
+
+### 3. Metadata Reading
+Access PDF metadata like author, creation date, title.
+
+### 4. Page Count & Info
+Get total pages and document dimensions.
+
+## Common Operations
+
+### Extract All Text
+```typescript
+import fs from 'fs';
+import pdf from 'pdf-parse';
+
+const dataBuffer = fs.readFileSync('document.pdf');
+const data = await pdf(dataBuffer);
+
+console.log(data.text);        // Full text content
+console.log(data.numpages);    // Number of pages
+console.log(data.info);        // PDF metadata
+```
+
+### Extract Text by Page
+```typescript
+const data = await pdf(dataBuffer);
+// Text includes page breaks
+// Split by page markers if needed
+```
+
+### Get PDF Info
+```typescript
+const data = await pdf(dataBuffer);
+console.log({
+    pages: data.numpages,
+    info: data.info,
+    metadata: data.metadata
+});
+```
+
+## Troubleshooting
+
+### "pdf-parse not found"
+Install the package: `npm install pdf-parse`
+
+### Scanned PDFs return no text
+Scanned PDFs are images. Use OCR (tesseract.js) instead.
+
+### Encrypted PDFs
+Password-protected PDFs cannot be read. Remove password first.
+
+### Memory Issues with Large Files
+For very large PDFs (>100MB), process in chunks or use streaming.
+
+## Advanced Topics
+
+For advanced PDF operations like filling forms, merging, or creating PDFs, see [ADVANCED.md](ADVANCED.md).
+
+## Examples
+
+### Quick Text Extraction
+```bash
+# User asks: "Extract text from this PDF"
+# 1. Read the PDF file
+# 2. Use pdf-parse to extract text
+# 3. Return the text content
+```
+
+### Get Page Count
+```bash
+# User asks: "How many pages in this PDF?"
+# 1. Parse the PDF
+# 2. Return numpages value
+```
+
+### Form Analysis
+```bash
+# User asks: "What fields are in this PDF form?"
+# 1. Parse the PDF
+# 2. Look for form field patterns
+# 3. List detected fields
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indiccoder/mentis-cli",
-  "version": "1.0.8",
+  "version": "1.1.0",
   "publishConfig": {
     "access": "public"
   },
@@ -50,7 +50,8 @@
     "screenshot-desktop": "^1.15.3",
     "uuid": "^13.0.0",
     "vscode-ripgrep": "^1.13.2",
-    "xlsx": "^0.18.5"
+    "xlsx": "^0.18.5",
+    "yaml": "^2.7.0"
   },
   "devDependencies": {
     "@types/figlet": "^1.7.0",
@@ -60,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`);
+}