poly-agent 1.0.3 → 1.0.5

package/dist/cli.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+import { intro, select, multiselect, spinner, log, outro, cancel, isCancel } from '@clack/prompts';
+import fs from 'fs/promises';
+import path from 'path';
+import { PromptLoader } from './lib/prompt-loader.js';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+// Get the prompts directory
+async function getPromptsDir() {
+    // Try multiple possible locations
+    const possiblePaths = [
+        path.join(process.cwd(), 'prompts'), // Local development
+        path.join(process.cwd(), 'node_modules', 'poly-agent', 'prompts'), // Installed package
+    ];
+    // Try to resolve via require if available
+    try {
+        const packagePath = require.resolve('poly-agent/package.json');
+        const packageDir = path.dirname(packagePath);
+        possiblePaths.unshift(path.join(packageDir, 'prompts'));
+    }
+    catch {
+        // Not installed as package, continue
+    }
+    // Check which path actually exists
+    for (const promptsPath of possiblePaths) {
+        try {
+            await fs.access(promptsPath);
+            return promptsPath;
+        }
+        catch {
+            continue;
+        }
+    }
+    // Fallback to first option
+    return possiblePaths[0];
+}
+// Map IDE to target directory
+const IDE_DIRECTORIES = {
+    'Cursor': '.cursor/commands',
+    'Antigravity': '.agent/workflows',
+    'Claude': '.claude/skills',
+};
+async function runInit() {
+    // Welcome message
+    intro('Welcome to PolyAgent CLI');
+    // Step 1: Select AI IDE
+    const selectedIDE = await select({
+        message: 'Choose the AI IDE you want to use:',
+        options: [
+            { value: 'Cursor', label: 'Cursor' },
+            { value: 'Claude', label: 'Claude' },
+            { value: 'Antigravity', label: 'Antigravity' }
+        ]
+    });
+    if (isCancel(selectedIDE)) {
+        cancel('Operation cancelled.');
+        process.exit(0);
+    }
+    // Step 2: Load available prompts
+    const promptsDir = await getPromptsDir();
+    const loader = new PromptLoader(promptsDir);
+    const promptFiles = await loader.listPrompts();
+    if (promptFiles.length === 0) {
+        log.error('No prompts found in the prompts directory.');
+        process.exit(1);
+    }
+    // Load prompt metadata for display
+    const promptOptions = await Promise.all(promptFiles.map(async (filename) => {
+        try {
+            const prompt = await loader.loadPrompt(filename);
+            return {
+                value: filename,
+                label: `${prompt.name} - ${prompt.description || 'No description'}`
+            };
+        }
+        catch (error) {
+            return {
+                value: filename,
+                label: filename.replace('.md', '')
+            };
+        }
+    }));
+    // Step 3: Multi-select prompts
+    const selectedPrompts = await multiselect({
+        message: 'Select prompts to install (use Space to select, Enter to continue):',
+        options: promptOptions,
+        required: true
+    });
+    if (isCancel(selectedPrompts)) {
+        cancel('Operation cancelled.');
+        process.exit(0);
+    }
+    // Step 4: Install prompts with shared instructions
+    const targetDir = IDE_DIRECTORIES[selectedIDE];
+    const fullTargetPath = path.join(process.cwd(), targetDir);
+    const s = spinner();
+    s.start(`Installing ${selectedPrompts.length} prompt(s) to ${targetDir}...`);
+    try {
+        // Create target directory if it doesn't exist
+        await fs.mkdir(fullTargetPath, { recursive: true });
+        // Install each selected prompt with shared instructions injected
+        const installPromises = selectedPrompts.map(async (filename) => {
+            // Load prompt with shared instructions injected
+            const prompt = await loader.loadPrompt(filename);
+            // Reconstruct the full file content with frontmatter
+            const fullContent = `---
+name: ${prompt.name}
+description: ${prompt.description}
+---
+${prompt.content}`;
+            if (selectedIDE === 'Claude') {
+                // For Claude, create a folder with the prompt name and SKILL.md inside
+                const promptName = path.basename(filename, '.md');
+                const skillFolderPath = path.join(fullTargetPath, promptName);
+                const skillFilePath = path.join(skillFolderPath, 'SKILL.md');
+                // Create the skill folder
+                await fs.mkdir(skillFolderPath, { recursive: true });
+                // Write the processed content to SKILL.md
+                await fs.writeFile(skillFilePath, fullContent, 'utf-8');
+                return `${promptName}/SKILL.md`;
+            }
+            else {
+                // For other IDEs, write directly
+                const targetPath = path.join(fullTargetPath, filename);
+                await fs.writeFile(targetPath, fullContent, 'utf-8');
+                return filename;
+            }
+        });
+        const installedFiles = await Promise.all(installPromises);
+        s.stop(`✓ Installed ${installedFiles.length} prompt(s) successfully`);
+        // Success message
+        log.success(`Prompts installed to: ${targetDir}`);
+        log.info(`Installed files:`);
+        installedFiles.forEach(file => {
+            log.info(`  - ${file}`);
+        });
+        outro('Installation complete! 🎉');
+    }
+    catch (error) {
+        s.stop('✗ Installation failed');
+        log.error(`Failed to install prompts: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
+    }
+}
+function showHelp() {
+    console.log(`
+PolyAgent CLI - Install AI IDE prompts
+
+Usage:
+  poly-agent init          Initialize and install prompts
+  poly-agent --help        Show this help message
+  poly-agent --version     Show version
+
+Examples:
+  npx poly-agent init      Install prompts for your AI IDE
+`);
+}
+function showVersion() {
+    try {
+        // Try to get version from installed package first
+        const packagePath = require.resolve('poly-agent/package.json');
+        const packageJson = require(packagePath);
+        console.log(`poly-agent v${packageJson.version}`);
+    }
+    catch {
+        try {
+            // Fallback to local package.json for development
+            const packageJson = require('../package.json');
+            console.log(`poly-agent v${packageJson.version}`);
+        }
+        catch {
+            console.log('poly-agent (version unknown)');
+        }
+    }
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    switch (command) {
+        case 'init':
+            await runInit();
+            break;
+        case '--help':
+        case '-h':
+        case 'help':
+            showHelp();
+            break;
+        case '--version':
+        case '-v':
+        case 'version':
+            showVersion();
+            break;
+        case undefined:
+            // No command provided, default to init for backward compatibility
+            await runInit();
+            break;
+        default:
+            log.error(`Unknown command: ${command}`);
+            showHelp();
+            process.exit(1);
+    }
+}
+main().catch((error) => {
+    console.error(`Fatal error: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+});

package/dist/lib/prompt-loader.js

@@ -0,0 +1,127 @@
+import fs from 'fs/promises';
+import path from 'path';
+export class PromptLoader {
+    promptsDir;
+    sharedInstructionsCache = null;
+    constructor(promptsDir) {
+        this.promptsDir = promptsDir;
+    }
+    /**
+     * Load all shared instructions from the _shared directory.
+     * These will be appended to every prompt.
+     */
+    async loadSharedInstructions() {
+        // Return cached instructions if available
+        if (this.sharedInstructionsCache !== null) {
+            return this.sharedInstructionsCache;
+        }
+        const sharedDir = path.join(this.promptsDir, '_shared');
+        const instructions = [];
+        try {
+            const files = await fs.readdir(sharedDir);
+            const mdFiles = files.filter(f => f.endsWith('.md'));
+            for (const file of mdFiles) {
+                const filePath = path.join(sharedDir, file);
+                const fileContent = await fs.readFile(filePath, 'utf-8');
+                // Parse frontmatter to get name, extract content
+                const frontmatterRegex = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
+                const match = fileContent.match(frontmatterRegex);
+                if (match) {
+                    const metadata = this.parseFrontmatter(match[1]);
+                    instructions.push({
+                        name: metadata.name || path.basename(file, '.md'),
+                        content: match[2].trim()
+                    });
+                }
+                else {
+                    // No frontmatter, use entire content
+                    instructions.push({
+                        name: path.basename(file, '.md'),
+                        content: fileContent.trim()
+                    });
+                }
+            }
+        }
+        catch (error) {
+            // _shared directory doesn't exist or is empty - that's okay
+            // Return empty array, shared instructions are optional
+        }
+        this.sharedInstructionsCache = instructions;
+        return instructions;
+    }
+    /**
+     * Clear the shared instructions cache.
+     * Useful if shared instructions are modified at runtime.
+     */
+    clearCache() {
+        this.sharedInstructionsCache = null;
+    }
+    async loadPrompt(filename, variables = {}) {
+        const filePath = path.join(this.promptsDir, filename);
+        try {
+            const fileContent = await fs.readFile(filePath, 'utf-8');
+            // Basic Frontmatter parsing
+            const frontmatterRegex = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
+            const match = fileContent.match(frontmatterRegex);
+            let name;
+            let description;
+            let content;
+            if (!match) {
+                // Fallback if no frontmatter
+                name = path.basename(filename, '.md');
+                description = 'No description provided.';
+                content = fileContent;
+            }
+            else {
+                const rawFrontmatter = match[1];
+                const metadata = this.parseFrontmatter(rawFrontmatter);
+                name = metadata.name || path.basename(filename, '.md');
+                description = metadata.description || '';
+                content = match[2];
+            }
+            // Inject variables
+            content = this.injectVariables(content, variables);
+            // Append shared instructions
+            const sharedInstructions = await this.loadSharedInstructions();
+            if (sharedInstructions.length > 0) {
+                const sharedContent = sharedInstructions
+                    .map(inst => `\n---\n\n${inst.content}`)
+                    .join('\n');
+                content = content + sharedContent;
+            }
+            return { name, description, content };
+        }
+        catch (error) {
+            throw new Error(`Failed to load prompt ${filename}: ${error}`);
+        }
+    }
+    parseFrontmatter(frontmatter) {
+        const lines = frontmatter.split('\n');
+        const metadata = {};
+        for (const line of lines) {
+            const [key, ...valueParts] = line.split(':');
+            if (key && valueParts.length > 0) {
+                metadata[key.trim()] = valueParts.join(':').trim();
+            }
+        }
+        return metadata;
+    }
+    injectVariables(content, variables) {
+        let result = content;
+        for (const [key, value] of Object.entries(variables)) {
+            // Replace {{KEY}}
+            result = result.replaceAll(`{{${key}}}`, value);
+        }
+        return result;
+    }
+    async listPrompts() {
+        try {
+            const files = await fs.readdir(this.promptsDir);
+            // Filter out _shared directory and only return .md files
+            return files.filter(f => f.endsWith('.md') && !f.startsWith('_'));
+        }
+        catch (error) {
+            return [];
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poly-agent",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "CLI installer for AI IDE prompts - install commands, skills, and workflows for Cursor, ClaudeCode, and Antigravity",
   "main": "dist/index.js",
   "bin": {

package/prompts/_shared/context-hook.md

@@ -0,0 +1,84 @@
+---
+name: Context Hook
+description: Shared instructions for automatic context dumping after file edits.
+type: shared
+---
+
+# Context Management Hook
+
+## Behavior
+
+After **every file edit** you make, you MUST update the project context file. This ensures continuity across conversations and helps maintain a clear record of progress.
+
+## When to Update Context
+
+1. **After any file edit** - Immediately after modifying, creating, or deleting a file
+2. **When the task context changes** - New goals, pivots, or scope changes
+3. **When explicitly mentioned** - If the user references `.context/` or asks about context
+4. **At conversation milestones** - Completing a feature, fixing a bug, reaching a checkpoint
+
+## Context File Location & Naming
+
+- **Directory**: `.context/`
+- **Filename**: Generate a short, descriptive kebab-case name based on the current task
+  - Examples: `feature-auth.md`, `bugfix-api-timeout.md`, `refactor-database-layer.md`, `setup-ci-pipeline.md`
+- **Persistence**: Use the SAME context file throughout a conversation/task. Only create a new one if the task fundamentally changes.
+
+## Context File Format
+
+Use this exact structure:
+
+```markdown
+---
+created: [ISO timestamp when first created]
+updated: [ISO timestamp of last update]
+task: [One-line task description]
+status: [in-progress | completed | blocked | paused]
+---
+
+# Context: [short-name]
+
+## Summary
+[2-3 sentence AI-generated summary of what this task is about and current state]
+
+## Files Changed
+- `path/to/file.ts` - [Brief description of change]
+- `path/to/another.ts` - [Brief description of change]
+
+## Current Goals
+1. [Primary goal]
+2. [Secondary goal]
+3. [etc.]
+
+## Progress
+- [x] [Completed item]
+- [x] [Completed item]
+- [ ] [Pending item]
+- [ ] [Pending item]
+
+## Next Steps
+- [Immediate next action]
+- [Following action]
+
+## Notes
+[Any important context, decisions made, blockers, or things to remember]
+```
+
+## Rules
+
+1. **Always update, never skip** - Even small edits warrant a context update
+2. **Be concise but complete** - Capture essential information without verbosity
+3. **Track ALL file changes** - Every file you touch should be listed
+4. **Maintain history** - Don't remove completed items from Progress, mark them done
+5. **Update timestamps** - Always update the `updated` field in frontmatter
+6. **Create directory if needed** - If `.context/` doesn't exist, create it
+
+## Example Workflow
+
+1. User asks: "Add authentication to the API"
+2. You create/update `.context/feature-api-auth.md` with initial goals
+3. You edit `src/auth/middleware.ts`
+4. You immediately update `.context/feature-api-auth.md` with the file change
+5. You edit `src/routes/login.ts`
+6. You update `.context/feature-api-auth.md` again
+7. Continue until task complete, then set status to `completed`