prompt-forge-studio-cli 1.0.0

package/README.md

@@ -0,0 +1,40 @@
+# forge
+
+Forge CLI Studio is a professional, premium terminal-native Prompt Engineering studio designed for rapid prompt generation, testing, and AI model evaluation.
+
+## Installation
+
+You can link this package globally to try it out:
+
+```bash
+cd forge-cli
+npm link
+```
+
+## Usage
+
+### Initialize a new project
+
+```bash
+forge init my-project
+```
+
+This will create a new directory, initialize a git repository, set up the required structure, and create a `forge.config.json` file.
+
+### Studio Mode
+
+Run the studio interactive REPL:
+
+```bash
+forge
+```
+
+Commands available in Studio Mode:
+- `:model` - Switch to a specific model.
+- `:models` - List available models and configure them.
+- `:test` - Test the current model.
+- `:test all` - Test all available models and display connection latency.
+- `:auto` - Toggle auto-failover mode.
+- `:key` - Configure API keys.
+- `:clear` - Clear the console.
+- `:exit` - Exit the studio.

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "prompt-forge-studio-cli",
+  "version": "1.0.0",
+  "description": "Professional terminal-native prompt engineering studio",
+  "main": "src/index.js",
+  "bin": {
+    "forge": "./src/index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "boxen": "^5.1.2",
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.5",
+    "commander": "^14.0.3",
+    "figlet": "^1.10.0",
+    "gradient-string": "^3.0.0",
+    "inquirer": "^8.2.7",
+    "ora": "^5.4.1"
+  }
+}

package/src/api.js

@@ -0,0 +1,69 @@
+const ora = require('ora');
+const { getHealthStatus } = require('./health');
+const { requireAuth } = require('./auth');
+const chalk = require('chalk');
+
+// Simulated AI responses based on prompt input
+async function generateResponse(prompt, model) {
+    const spinner = ora(`Generating response with ${chalk.cyan(model)}...`).start();
+
+    // Simulate network latency
+    const latency = Math.floor(Math.random() * 500) + 500;
+    await new Promise(resolve => setTimeout(resolve, latency));
+
+    // Simulated failure logic: pretend gemini is currently having issues occasionally
+    if (model === 'gemini' && Math.random() > 0.5) {
+        spinner.fail(`Failed to get response from ${chalk.cyan(model)}`);
+        throw new Error('Provider connection timeout');
+    }
+
+    spinner.succeed(`Received response from ${chalk.cyan(model)} in ${latency}ms`);
+
+    let responseText;
+    if (prompt.toLowerCase().includes('hello') || prompt.toLowerCase().includes('hi')) {
+        responseText = `Hello! I am the ${model} model. How can I help you in Forge Studio today?`;
+    } else {
+        responseText = `This is a generated response from ${model} for your prompt: "${prompt}".\n\n- Point 1: Simulated insight\n- Point 2: Prompt engineering tip\n- Point 3: Evaluation matrix.`;
+    }
+
+    return {
+        text: responseText,
+        metadata: {
+            model,
+            latency
+        }
+    };
+}
+
+async function executeWithFailover(prompt, primaryModel, autoFailover) {
+    const healthManager = require('./health');
+
+    try {
+        return await generateResponse(prompt, primaryModel);
+    } catch (error) {
+        if (!autoFailover) {
+            throw error;
+        }
+
+        // Auto-failover logic
+        console.log(chalk.yellow(`\n⚠ Auto-failover triggered. ${primaryModel} failed.`));
+        const allModels = ['gpt-4o', 'claude', 'gemini'].filter(m => m !== primaryModel);
+
+        // Find next healthy model (simulated)
+        for (const backup of allModels) {
+            try {
+                console.log(chalk.dim(`Attempting fallback to ${backup}...`));
+                return await generateResponse(prompt, backup);
+            } catch (backupError) {
+                // continue
+            }
+        }
+
+        throw new Error('All failover attempts exhausted.');
+    }
+}
+
+module.exports = {
+    generateResponse,
+    executeWithFailover
+};

package/src/auth.js

@@ -0,0 +1,69 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+
+const FORGE_HOME = path.join(os.homedir(), '.forge');
+const AUTH_FILE = path.join(FORGE_HOME, 'auth.json');
+
+function ensureForgeHomeDir() {
+    if (!fs.existsSync(FORGE_HOME)) {
+        fs.mkdirSync(FORGE_HOME, { recursive: true });
+    }
+}
+
+function getAuth() {
+    if (!fs.existsSync(AUTH_FILE)) {
+        return {};
+    }
+    try {
+        const rawData = fs.readFileSync(AUTH_FILE, 'utf8');
+        return JSON.parse(rawData);
+    } catch (err) {
+        return {};
+    }
+}
+
+function setAuth(provider, key) {
+    ensureForgeHomeDir();
+    const currentAuth = getAuth();
+    currentAuth[provider] = key;
+    fs.writeFileSync(AUTH_FILE, JSON.stringify(currentAuth, null, 2), { mode: 0o600 });
+}
+
+async function requireAuth() {
+    const auth = getAuth();
+    if (Object.keys(auth).length === 0) {
+        console.log(chalk.yellow('\nNo API keys found. Let\'s set up your primary provider.'));
+
+        const { provider } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'provider',
+                message: 'Select an AI provider to configure:',
+                choices: ['openai', 'anthropic', 'gemini']
+            }
+        ]);
+
+        const { key } = await inquirer.prompt([
+            {
+                type: 'password',
+                name: 'key',
+                message: `Enter your ${provider.toUpperCase()} API Key:`,
+                mask: '*'
+            }
+        ]);
+
+        setAuth(provider, key);
+        console.log(chalk.green('\n✔ API key saved securely locally.'));
+        return getAuth();
+    }
+    return auth;
+}
+
+module.exports = {
+    getAuth,
+    setAuth,
+    requireAuth
+};

package/src/config.js

@@ -0,0 +1,28 @@
+const fs = require('fs');
+const path = require('path');
+
+const CONFIG_FILE = 'forge.config.json';
+
+function getConfig() {
+    const configPath = path.join(process.cwd(), CONFIG_FILE);
+    if (!fs.existsSync(configPath)) {
+        return null;
+    }
+    try {
+        const rawData = fs.readFileSync(configPath, 'utf8');
+        return JSON.parse(rawData);
+    } catch (error) {
+        console.error('Error reading forge.config.json', error.message);
+        return null;
+    }
+}
+
+function updateConfig(newConfig) {
+    const configPath = path.join(process.cwd(), CONFIG_FILE);
+    fs.writeFileSync(configPath, JSON.stringify(newConfig, null, 2));
+}
+
+module.exports = {
+    getConfig,
+    updateConfig,
+};

package/src/health.js

@@ -0,0 +1,38 @@
+const ora = require('ora');
+
+const MODELS = ['gpt-4o', 'claude', 'gemini'];
+
+// Simulates checking latency and status for available models
+async function checkAllModelsHealth() {
+    const results = [];
+    const spinner = ora('Pinging AI providers...').start();
+
+    for (const model of MODELS) {
+        // Simulate latency and status randomly
+        const latency = Math.floor(Math.random() * 1000) + 100;
+        let status = 'Active';
+
+        // Randomize some issues for realism
+        if (model === 'gemini') {
+            status = 'Offline';
+        } else if (latency > 800) {
+            status = 'Degraded';
+        }
+
+        results.push({
+            name: model,
+            status: status,
+            latency: status === 'Offline' ? null : latency
+        });
+
+        // Small delay to make spinner look realistic
+        await new Promise(r => setTimeout(r, 400));
+    }
+
+    spinner.succeed('Health check complete');
+    return results;
+}
+
+module.exports = {
+    checkAllModelsHealth
+};

package/src/index.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const { initProject } = require('./init');
+const { startStudio } = require('./studio');
+const { showBanner } = require('./ui');
+const fs = require('fs');
+const path = require('path');
+
+program
+    .name('forge')
+    .description('Prompt Forge Studio - Professional Terminal-Native Prompt Engineering Studio')
+    .version('1.0.0');
+
+// Command: init
+program
+    .command('init [project]')
+    .description('Initialize a new Forge project')
+    .action((project) => {
+        initProject(project || 'prompt-forge-project');
+    });
+
+// Default behavior: Studio mode
+program
+    .action(() => {
+        const isProjectDir = fs.existsSync(path.join(process.cwd(), 'forge.config.json'));
+
+        showBanner();
+
+        if (!isProjectDir) {
+            console.log('\nWarning: Not inside a Forge project. Run `forge init <project>` to set one up.\n');
+        }
+
+        startStudio();
+    });
+
+program.parse(process.argv);

package/src/init.js

@@ -0,0 +1,101 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+const ora = require('ora');
+const boxen = require('boxen');
+
+function initProject(projectName) {
+    const projectPath = path.join(process.cwd(), projectName);
+
+    console.log(
+        boxen(chalk.bold.cyan(`Initializing Forge Studio Project: ${projectName}`), {
+            padding: 1,
+            margin: 1,
+            borderStyle: 'round',
+            borderColor: 'cyan'
+        })
+    );
+
+    const spinner = ora('Creating directories...').start();
+
+    try {
+        if (!fs.existsSync(projectPath)) {
+            fs.mkdirSync(projectPath);
+        }
+
+        // Create folder structure
+        const dirs = ['prompts', 'sessions', 'logs', '.forge'];
+        dirs.forEach(dir => {
+            fs.mkdirSync(path.join(projectPath, dir), { recursive: true });
+        });
+
+        spinner.succeed('Directories created');
+
+        // Create files
+        spinner.start('Generating configuration files...');
+
+        const configContent = {
+            project: projectName,
+            version: '1.0.0',
+            defaultModel: 'gpt-4o',
+            autoFailover: true
+        };
+        fs.writeFileSync(
+            path.join(projectPath, 'forge.config.json'),
+            JSON.stringify(configContent, null, 2)
+        );
+
+        const gitignoreContent = `.forge/
+logs/
+.env
+*.log
+node_modules/
+`;
+        fs.writeFileSync(
+            path.join(projectPath, '.gitignore'),
+            gitignoreContent
+        );
+
+        const readmeContent = `# ${projectName}
+    
+A Prompt Forge Studio project.
+
+## Directory Structure
+- \`/prompts\` - Your prompt templates
+- \`/sessions\` - Saved studio sessions
+- \`/logs\` - Execution logs
+- \`/.forge\` - Local project cache (git-ignored)
+`;
+        fs.writeFileSync(
+            path.join(projectPath, 'README.md'),
+            readmeContent
+        );
+
+        spinner.succeed('Configuration files generated');
+
+        // Initialize git repo if not exists
+        spinner.start('Initializing git repository...');
+        try {
+            if (!fs.existsSync(path.join(projectPath, '.git'))) {
+                execSync('git init', { cwd: projectPath, stdio: 'ignore' });
+                spinner.succeed('Git repository initialized');
+            } else {
+                spinner.info('Git repository already exists');
+            }
+        } catch (e) {
+            spinner.warn('Git is not installed or failed to initialize');
+        }
+
+        console.log('\n' + chalk.green('✔ Project setup complete!'));
+        console.log(`\nNext steps:\n  ${chalk.cyan(`cd ${projectName}`)}\n  ${chalk.cyan('forge')}`);
+
+    } catch (error) {
+        spinner.fail('Failed to initialize project');
+        console.error(chalk.red(error.message));
+    }
+}
+
+module.exports = {
+    initProject
+};

package/src/studio.js

@@ -0,0 +1,149 @@
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const { requireAuth, setAuth } = require('./auth');
+const { executeWithFailover } = require('./api');
+const { checkAllModelsHealth } = require('./health');
+const { showSessionPanel, showModelComparison, formatAIResponse, showInfoBox, showErrorBox } = require('./ui');
+const { getConfig } = require('./config');
+
+const AVAILABLE_MODELS = ['gpt-4o', 'claude', 'gemini'];
+
+let state = {
+    model: 'gpt-4o',
+    status: 'Active',
+    autoFailover: true
+};
+
+async function startStudio() {
+    await requireAuth();
+
+    // Load project config if available
+    const config = getConfig();
+    if (config) {
+        if (config.defaultModel) state.model = config.defaultModel;
+        if (config.autoFailover !== undefined) state.autoFailover = config.autoFailover;
+    }
+
+    showSessionPanel(state.model, state.status, state.autoFailover);
+    await studioLoop();
+}
+
+async function handleCommand(input) {
+    const cmd = input.trim().toLowerCase();
+
+    switch (cmd) {
+        case ':exit':
+            console.log(chalk.cyan('\nExiting Forge Studio. Goodbye!\n'));
+            process.exit(0);
+            break;
+
+        case ':clear':
+            console.clear();
+            showSessionPanel(state.model, state.status, state.autoFailover);
+            break;
+
+        case ':auto':
+            state.autoFailover = !state.autoFailover;
+            showInfoBox(`Auto-failover is now ${state.autoFailover ? 'ON' : 'OFF'}`);
+            showSessionPanel(state.model, state.status, state.autoFailover);
+            break;
+
+        case ':model':
+            const { selectedModel } = await inquirer.prompt([{
+                type: 'list',
+                name: 'selectedModel',
+                message: 'Select a primary model:',
+                choices: AVAILABLE_MODELS
+            }]);
+            state.model = selectedModel;
+            showSessionPanel(state.model, state.status, state.autoFailover);
+            break;
+
+        case ':models':
+            console.log(chalk.cyan('\nAvailable models configuration goes here.\n'));
+            break;
+
+        case ':test all':
+            const results = await checkAllModelsHealth();
+            showModelComparison(results);
+            break;
+
+        case ':test':
+            state.status = 'Testing...';
+            showSessionPanel(state.model, state.status, state.autoFailover);
+            try {
+                await executeWithFailover('hello', state.model, false);
+                state.status = 'Active';
+            } catch (e) {
+                state.status = 'Offline';
+            }
+            showSessionPanel(state.model, state.status, state.autoFailover);
+            break;
+
+        case ':key':
+            const { provider } = await inquirer.prompt([{
+                type: 'list',
+                name: 'provider',
+                message: 'Which provider to configure?',
+                choices: AVAILABLE_MODELS.map(m => m === 'gpt-4o' ? 'openai' : (m === 'claude' ? 'anthropic' : 'gemini'))
+            }]);
+            const { key } = await inquirer.prompt([{
+                type: 'password',
+                name: 'key',
+                message: `Enter new API key for ${provider}:`,
+                mask: '*'
+            }]);
+            setAuth(provider, key);
+            showInfoBox(`Key updated for ${provider}`);
+            break;
+
+        default:
+            if (cmd.startsWith(':')) {
+                showErrorBox('Unknown Command', `Command ${cmd} not recognized. Type :exit to quit.`);
+            } else {
+                // Handle prompt generation
+                try {
+                    const result = await executeWithFailover(input, state.model, state.autoFailover);
+
+                    if (result.metadata.model !== state.model) {
+                        // It failed over to a different model!
+                        showInfoBox(`Response was generated by fallback model: ${result.metadata.model}`);
+                        if (state.autoFailover) {
+                            state.status = 'Degraded';
+                            showSessionPanel(state.model, state.status, state.autoFailover);
+                        }
+                    }
+
+                    formatAIResponse(result.text, result.metadata);
+                } catch (error) {
+                    showErrorBox('Generation Failed', error.message);
+                    if (!state.autoFailover) {
+                        console.log(chalk.cyan('Hint: Try running `:test all` to check model health, or enable auto-failover with `:auto`.\n'));
+                    }
+                    state.status = 'Offline';
+                    showSessionPanel(state.model, state.status, state.autoFailover);
+                }
+            }
+    }
+}
+
+async function studioLoop() {
+    while (true) {
+        const { promptInput } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'promptInput',
+                message: chalk.cyan('forge> '),
+                prefix: ''
+            }
+        ]);
+
+        if (!promptInput.trim()) continue;
+
+        await handleCommand(promptInput);
+    }
+}
+
+module.exports = {
+    startStudio
+};

package/src/ui.js

@@ -0,0 +1,126 @@
+const figlet = require('figlet');
+const gradient = require('gradient-string');
+const boxen = require('boxen');
+const chalk = require('chalk');
+const Table = require('cli-table3');
+
+function showBanner() {
+    const bannerText = figlet.textSync('FORGE STUDIO', { font: 'Standard', horizontalLayout: 'fitted' });
+    console.log(gradient.pastel.multiline(bannerText));
+}
+
+function showSessionPanel(model, status, autoFailover) {
+    let statusColor;
+    switch (status.toLowerCase()) {
+        case 'active':
+            statusColor = chalk.green(status);
+            break;
+        case 'degraded':
+            statusColor = chalk.yellow(status);
+            break;
+        case 'offline':
+            statusColor = chalk.red(status);
+            break;
+        default:
+            statusColor = chalk.white(status);
+    }
+
+    const autoText = autoFailover ? chalk.green('ON') : chalk.red('OFF');
+
+    const content = [
+        chalk.bold.cyan('Forge Studio (beta)'),
+        `Model: ${chalk.white(model)}`,
+        `Status: ${statusColor}`,
+        `Auto-Failover: ${autoText}`
+    ].join('\n');
+
+    console.log(
+        boxen(content, {
+            padding: 1,
+            margin: { top: 1, bottom: 1 },
+            borderStyle: 'bold',
+            borderColor: 'blue',
+            dimBorder: true
+        })
+    );
+}
+
+function showModelComparison(modelsInfo) {
+    const table = new Table({
+        head: [chalk.cyan('Model'), chalk.cyan('Status'), chalk.cyan('Latency')],
+        chars: {
+            'top': '─', 'top-mid': '┬', 'top-left': '┌', 'top-right': '┐',
+            'bottom': '─', 'bottom-mid': '┴', 'bottom-left': '└', 'bottom-right': '┘',
+            'left': '│', 'left-mid': '├', 'mid': '─', 'mid-mid': '┼',
+            'right': '│', 'right-mid': '┤', 'middle': '│'
+        }
+    });
+
+    modelsInfo.forEach(info => {
+        let statusColor, latencyDisplay;
+
+        if (info.status === 'Active') {
+            statusColor = chalk.green(info.status);
+            latencyDisplay = info.latency ? chalk.white(`${info.latency}ms`) : '-';
+        } else if (info.status === 'Degraded') {
+            statusColor = chalk.yellow(info.status);
+            latencyDisplay = info.latency ? chalk.yellow(`${info.latency}ms`) : '-';
+        } else {
+            statusColor = chalk.red(info.status);
+            latencyDisplay = chalk.dim('-');
+        }
+
+        table.push([info.name, statusColor, latencyDisplay]);
+    });
+
+    console.log('\n' + table.toString() + '\n');
+}
+
+function formatAIResponse(text, metadata = {}) {
+    const metaText = Object.keys(metadata).length > 0
+        ? chalk.dim(`\n\n---\n[Model: ${metadata.model || 'unknown'} | Latency: ${metadata.latency || 0}ms]`)
+        : '';
+
+    const boxedResponse = boxen(chalk.white(text) + metaText, {
+        padding: 1,
+        margin: { top: 1, bottom: 1 },
+        borderStyle: 'round',
+        borderColor: 'magenta',
+        title: chalk.magenta.bold(' AI Response '),
+        titleAlignment: 'left'
+    });
+
+    console.log(boxedResponse);
+}
+
+function showErrorBox(title, message) {
+    console.log(
+        boxen(chalk.red(message), {
+            padding: 1,
+            margin: 1,
+            borderStyle: 'double',
+            borderColor: 'red',
+            title: chalk.red.bold(` Error: ${title} `)
+        })
+    );
+}
+
+function showInfoBox(message) {
+    console.log(
+        boxen(chalk.cyan(message), {
+            padding: 1,
+            margin: 1,
+            borderStyle: 'round',
+            borderColor: 'cyan'
+        })
+    );
+}
+
+module.exports = {
+    showBanner,
+    showSessionPanel,
+    showModelComparison,
+    formatAIResponse,
+    showErrorBox,
+    showInfoBox
+};

package/test-project/README.md

@@ -0,0 +1,9 @@
+# test-project
+    
+A Prompt Forge Studio project.
+
+## Directory Structure
+- `/prompts` - Your prompt templates
+- `/sessions` - Saved studio sessions
+- `/logs` - Execution logs
+- `/.forge` - Local project cache (git-ignored)

package/test-project/forge.config.json

@@ -0,0 +1,6 @@
+{
+  "project": "test-project",
+  "version": "1.0.0",
+  "defaultModel": "gpt-4o",
+  "autoFailover": true
+}