shoud-cli 1.0.0

package/bin/shoud.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+const { program } = require('commander');
+const chalk = require('chalk');
+const { login } = require('../src/auth/deviceFlow');
+const { executeTask } = require('../src/runtime/agentLoop');
+
+// ─── Banner Art ───────────────────────────────────────────────
+const BANNER_ART = [
+  "  ███████╗██╗  ██╗ ██████╗ ██████╗ ███████╗██╗   ██╗██╗   ██╗██████╗",
+  "  ██╔════╝██║  ██║██╔═══██╗██╔══██╗██╔════╝██║   ██║██║   ██║██╔══██╗",
+  "  ███████╗███████║██║   ██║██║  ██║███████╗██║   ██║██║   ██║██████╔╝",
+  "  ╚════██║██╔══██║██║   ██║██║  ██║╚════██║██║   ██║██║   ██║██╔══██╗",
+  "  ███████║██║  ██║╚██████╔╝██████╔╝███████║╚██████╔╝╚██████╔╝██║  ██║",
+  "  ╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝ ╚═════╝  ╚═════╝ ╚═╝  ╚═╝"
+];
+
+const SLEEP = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// ─── Animated Banner ──────────────────────────────────────────
+async function renderAnimatedBanner() {
+  if (!process.stdout.isTTY) {
+    console.log(chalk.hex('#B5F96C')(BANNER_ART.join('\n')));
+    console.log(chalk.hex('#B5F96C').bold('  Give your computer a job.\n'));
+    return;
+  }
+
+  const colorGradients = [
+    ['#364B1D', '#5E8232', '#86B947', '#B5F96C'],
+    ['#5E8232', '#86B947', '#B5F96C', '#DDFFA8'],
+    ['#86B947', '#B5F96C', '#FFFFFF', '#B5F96C'],
+    ['#B5F96C', '#B5F96C', '#B5F96C', '#9EEB49']
+  ];
+
+  for (const colors of colorGradients) {
+    process.stdout.write('\x1B[?25l');
+    process.stdout.write('\r\x1B[K');
+    console.clear();
+    console.log();
+
+    BANNER_ART.forEach((line, index) => {
+      const color = colors[index % colors.length];
+      console.log(chalk.hex(color).bold(line));
+    });
+
+    console.log(
+      chalk.hex('#3B472E')(
+        '  ┌──────────────────────────────────────────────────────┐\n' +
+        '  │'
+      ) +
+      chalk.hex('#B5F96C').bold('          Give your computer a job.           ') +
+      chalk.hex('#3B472E')(
+        '│\n' +
+        '  └──────────────────────────────────────────────────────┘\n'
+      )
+    );
+
+    await SLEEP(75);
+  }
+
+  process.stdout.write('\x1B[?25h');
+}
+
+// ─── Custom Help ──────────────────────────────────────────────
+async function customHelp() {
+  console.log(chalk.hex('#B5F96C').bold('\n  SHOUD Terminal Agent - Command Reference\n'));
+  console.log(chalk.gray('  Usage: shoud [command] OR shoud "[prompt]"\n'));
+
+  console.log(chalk.white.bold('  Commands:'));
+  console.log(`    ${chalk.hex('#B5F96C')('shoud login')}     Authenticate this device with your Google account.`);
+  console.log(`    ${chalk.hex('#B5F96C')('shoud help')}      Display this beautiful help menu.`);
+  console.log(`    ${chalk.hex('#B5F96C')('shoud status')}    Check your current credit balance and active plan.\n`);
+
+  console.log(chalk.white.bold('  Autonomous Execution:'));
+  console.log(chalk.gray('    Wrap your instructions in quotes to trigger the agent loop.'));
+  console.log(`    ${chalk.hex('#B5F96C')('>')} shoud "Refactor the auth middleware to use JWTs"`);
+  console.log(`    ${chalk.hex('#B5F96C')('>')} shoud "Run npm test and fix any failing test cases"\n`);
+}
+
+// ─── Main ─────────────────────────────────────────────────────
+async function main() {
+  const args = process.argv.slice(2);
+
+  // Intercept help commands and empty input
+  if (args.length === 0 || args[0] === 'help' || args[0] === '--help') {
+    await renderAnimatedBanner();
+    await customHelp();
+    return;
+  }
+
+  program
+    .version('1.0.0')
+    .description('SHOUD Terminal Agent');
+
+  program
+    .command('login')
+    .description('Authenticate this device with your SHOUD account')
+    .action(login);
+
+  // Placeholder for status – you can replace with real implementation
+  program
+    .command('status')
+    .description('Check your current credit balance and active plan')
+    .action(() => {
+      console.log(chalk.yellow('  Status command not yet implemented.'));
+    });
+
+  program
+    .argument('[prompt...]', 'The task you want SHOUD to execute')
+    .action(async (promptArr) => {
+      if (!promptArr || promptArr.length === 0) {
+        console.log(chalk.gray('  Usage: shoud "fix the build errors"'));
+        return;
+      }
+      const taskPrompt = promptArr.join(' ');
+      await executeTask(taskPrompt);
+    });
+
+  program.parse(process.argv);
+}
+
+main();

package/install.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+set -e
+
+echo "Installing SHOUD Agent..."
+echo "Give your computer a job."
+
+# Check if npm is installed
+if ! command -v npm &> /dev/null
+then
+    echo "Error: npm could not be found. Please install Node.js and npm first."
+    exit 1
+fi
+
+npm install -g shoud-cli
+
+echo ""
+echo "✓ Installation complete."
+echo "Run 'shoud login' to authenticate your device."

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "shoud-cli",
+  "version": "1.0.0",
+  "description": "SHOUD Terminal Agent: Give your computer a job.",
+  "main": "bin/shoud.js",
+  "bin": {
+    "shoud": "./bin/shoud.js"
+  },
+  "scripts": {
+    "start": "node ./bin/shoud.js"
+  },
+  "dependencies": {
+    "axios": "^1.6.8",
+    "chalk": "^4.1.2",
+    "commander": "^11.0.0",
+    "inquirer": "^8.2.6",
+    "open": "^8.4.2",
+    "ora": "^5.4.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/auth/deviceFlow.js

@@ -0,0 +1,40 @@
+const open = require('open');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const SESSION_FILE = path.join(os.homedir(), '.shoud_session');
+
+async function login() {
+  console.log(chalk.cyan('Opening browser to sign in via shoud.online...'));
+  await open('https://shoud.online/login');
+  
+  console.log(chalk.gray('\nOnce signed in, copy your session token from the browser.'));
+  
+  const { token } = await inquirer.prompt([
+    {
+      type: 'password',
+      name: 'token',
+      message: 'Paste your session token:',
+      mask: '*'
+    }
+  ]);
+
+  if (token) {
+    fs.writeFileSync(SESSION_FILE, token, { encoding: 'utf-8', mode: 0o600 });
+    console.log(chalk.green('\n✓ Signed in successfully. Device connected.'));
+  } else {
+    console.log(chalk.red('\nLogin failed: No token provided.'));
+  }
+}
+
+function getToken() {
+  if (!fs.existsSync(SESSION_FILE)) {
+    return null;
+  }
+  return fs.readFileSync(SESSION_FILE, 'utf-8').trim();
+}
+
+module.exports = { login, getToken };

package/src/context/checkpoint.js

@@ -0,0 +1,23 @@
+const fs = require('fs');
+const path = require('path');
+
+const CHECKPOINT_FILE = path.join(process.cwd(), '.shoud_checkpoint.json');
+
+function saveCheckpoint(state) {
+  fs.writeFileSync(CHECKPOINT_FILE, JSON.stringify(state, null, 2));
+}
+
+function loadCheckpoint() {
+  if (fs.existsSync(CHECKPOINT_FILE)) {
+    return JSON.parse(fs.readFileSync(CHECKPOINT_FILE, 'utf-8'));
+  }
+  return null;
+}
+
+function clearCheckpoint() {
+  if (fs.existsSync(CHECKPOINT_FILE)) {
+    fs.unlinkSync(CHECKPOINT_FILE);
+  }
+}
+
+module.exports = { saveCheckpoint, loadCheckpoint, clearCheckpoint };

package/src/permissions/engine.js

@@ -0,0 +1,34 @@
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+
+// In a full implementation, this could read from a .shoudignore or local config
+const alwaysAllowedCommands = new Set(['ls', 'pwd', 'git status']);
+
+async function verifyPermission(toolName, input) {
+  if (toolName === 'read_file') return true; // Safe operation
+  
+  const commandContext = input.command || input.path || 'unknown';
+
+  if (toolName === 'execute_shell' && alwaysAllowedCommands.has(commandContext)) {
+    return true;
+  }
+
+  console.log(chalk.yellow(`\n⚠ SHOUD requests permission to run: ${chalk.bold(toolName)}`));
+  console.log(chalk.gray(`Target: ${commandContext}`));
+
+  const { permission } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'permission',
+      message: 'Allow this operation?',
+      choices: [
+        { name: 'Allow once', value: 'once' },
+        { name: 'Deny', value: 'deny' }
+      ]
+    }
+  ]);
+
+  return permission === 'once';
+}
+
+module.exports = { verifyPermission };

package/src/runtime/agentLoop.js

@@ -0,0 +1,104 @@
+const axios = require('axios');
+const chalk = require('chalk');
+const ora = require('ora');
+const open = require('open');
+const { getToken } = require('../auth/deviceFlow');
+const { verifyPermission } = require('../permissions/engine');
+const { executeTool } = require('../tools/index');
+const { saveCheckpoint, loadCheckpoint, clearCheckpoint } = require('../context/checkpoint');
+
+const API_URL = process.env.SHOUD_API_URL || 'https://shoud.online/api';
+
+async function executeTask(prompt) {
+  const token = getToken();
+  if (!token) {
+    console.log(chalk.red('Not signed in. Run `shoud login` first.'));
+    return;
+  }
+
+  let messages = [];
+  const existingState = loadCheckpoint();
+
+  if (existingState) {
+    console.log(chalk.cyan('● Restoring task context from checkpoint...'));
+    messages = existingState.messages;
+  } else {
+    messages.push({ role: 'user', content: prompt });
+  }
+
+  let taskComplete = false;
+  const spinner = ora('SHOUD is thinking...').start();
+
+  while (!taskComplete) {
+    try {
+      const response = await axios.post(`${API_URL}/agent/infer`, {
+        messages,
+        estimatedBudget: 0.10 // 10 cents max budget per loop iteration
+      }, {
+        headers: { Authorization: `Bearer ${token}` }
+      });
+
+      const aiMessage = response.data;
+      messages.push({ role: 'assistant', content: aiMessage.content });
+      spinner.stop();
+
+      if (aiMessage.stop_reason === 'tool_use') {
+        for (const block of aiMessage.content) {
+          if (block.type === 'tool_use') {
+            console.log(chalk.blue(`\n● Agent requested: ${block.name}`));
+            
+            const isAllowed = await verifyPermission(block.name, block.input);
+            let toolResult = '';
+
+            if (isAllowed) {
+              spinner.start(`Executing ${block.name}...`);
+              toolResult = executeTool(block.name, block.input);
+              spinner.stop();
+              console.log(chalk.green(`✓ Tool executed.`));
+            } else {
+              toolResult = "User denied permission to execute this tool.";
+              console.log(chalk.red(`✕ Permission denied.`));
+            }
+
+            messages.push({
+              role: 'user',
+              content: [{ type: 'tool_result', tool_use_id: block.id, content: toolResult }]
+            });
+            
+            // Save state after tool execution
+            saveCheckpoint({ messages });
+          }
+        }
+        spinner.start('Analyzing tool results...');
+      } else {
+        // Task completed normally
+        taskComplete = true;
+        clearCheckpoint();
+        
+        // Print the final text block from Claude
+        const finalResponse = aiMessage.content.find(c => c.type === 'text')?.text || 'Done.';
+        console.log(chalk.green('\n✓ Task Complete.\n'));
+        console.log(chalk.white(finalResponse));
+      }
+
+    } catch (error) {
+      spinner.stop();
+      if (error.response && error.response.status === 402) {
+        console.log(chalk.red('\n⏸ Task paused. Insufficient SHOUD Credits.'));
+        console.log(chalk.gray(`Balance: $${error.response.data.balance.toFixed(4)}`));
+        saveCheckpoint({ messages });
+        
+        console.log(chalk.cyan('Opening browser to add credits...'));
+        await open('https://shoud.vantyrixtek.online/?amount=10');
+        console.log(chalk.gray('Run your command again once credits are added to resume.'));
+        return;
+      } else {
+        console.log(chalk.red(`\nError: ${error.response?.data?.error || error.message}`));
+        saveCheckpoint({ messages });
+        return;
+      }
+    }
+  }
+}
+
+module.exports = { executeTask };

package/src/tools/index.js

@@ -0,0 +1,21 @@
+const { execSync } = require('child_process');
+const fs = require('fs');
+
+function executeTool(toolName, input) {
+  try {
+    if (toolName === 'execute_shell') {
+      const output = execSync(input.command, { encoding: 'utf-8', stdio: 'pipe' });
+      return output.trim() || 'Command executed successfully with no output.';
+    } 
+    
+    if (toolName === 'read_file') {
+      return fs.readFileSync(input.path, 'utf-8');
+    }
+
+    throw new Error(`Tool ${toolName} is not supported locally.`);
+  } catch (error) {
+    return `Error executing tool: ${error.message}`;
+  }
+}
+
+module.exports = { executeTool };