glad-web 1.0.7

package/lib/ai-tools/demo/responses.js

@@ -0,0 +1,88 @@
+// 50 randomized responses for demo mode
+// Topics: AI coding, mobile development, remote terminals, vibe coding, tech wisdom
+
+const RESPONSES = [
+  // AI Coding Assistant vibes
+  "AI-powered coding is like having a genius pair programmer who never sleeps!",
+  "The future of development is collaborative - humans and AI working together.",
+  "Code faster, debug smarter, ship sooner. That's the AI advantage.",
+  "Sometimes the best code is written when you're away from your desk.",
+  "AI assistants don't replace developers, they amplify their potential.",
+
+  // Mobile development
+  "Mobile-first isn't just design philosophy - it's a lifestyle.",
+  "Your next breakthrough idea might come while you're on the go.",
+  "The best development environment is the one you have with you.",
+  "Coding from your phone? Welcome to the future!",
+  "Distance is no barrier when your terminal fits in your pocket.",
+
+  // Remote terminal access
+  "SSH has evolved - now it's in your hand.",
+  "Terminal access from anywhere opens infinite possibilities.",
+  "Your development machine, always within reach.",
+  "The cloud isn't just for deployment anymore.",
+  "Remote doesn't mean disconnected.",
+
+  // Vibe coding
+  "Great code comes from great vibes.",
+  "The best debugging happens with a clear mind.",
+  "Inspiration strikes at unexpected moments - be ready!",
+  "Code flows better when you're in the zone.",
+  "Sometimes you need to step away to see the solution clearly.",
+
+  // Tech wisdom
+  "The right tool at the right time makes all the difference.",
+  "Automation isn't lazy - it's efficient.",
+  "Every line of code is a conversation with the future.",
+  "Simplicity is the ultimate sophistication.",
+  "Build tools that make you excited to work.",
+
+  // AI tools ecosystem
+  "Claude, Aider, Copilot - choose your AI companion wisely.",
+  "The best AI tool is the one that matches your workflow.",
+  "Multiple AI assistants? Why choose when you can have them all?",
+  "Each AI has its strengths - know when to use which.",
+  "The AI coding revolution is here, and it's spectacular.",
+
+  // Developer productivity
+  "Context switching costs time - keep your flow intact.",
+  "The fastest code is the code you don't have to write.",
+  "Good tools get out of your way. Great tools elevate your work.",
+  "Productivity isn't about hours - it's about focus.",
+  "Work smarter, not just harder.",
+
+  // Terminal culture
+  "The terminal is where magic happens.",
+  "Command line mastery is a superpower.",
+  "GUI is great, but CLI is poetry.",
+  "Real developers aren't afraid of the terminal.",
+  "There's something beautiful about green text on black.",
+
+  // Innovation & future
+  "The tools we build today shape tomorrow's possibilities.",
+  "Innovation happens when convenience meets capability.",
+  "The future of coding is more accessible than ever.",
+  "Technology should adapt to you, not the other way around.",
+  "We're living in the golden age of developer tools.",
+
+  // Collaboration
+  "The best solutions come from diverse perspectives.",
+  "Share your workflow, inspire others.",
+  "Community-driven development moves faster.",
+  "Open source is the rising tide that lifts all boats.",
+  "Collaboration multiplies creativity.",
+];
+
+/**
+ * Get a random response from the pool
+ * @returns {string} Random response
+ */
+function getRandomResponse() {
+  const index = Math.floor(Math.random() * RESPONSES.length);
+  return RESPONSES[index];
+}
+
+module.exports = {
+  RESPONSES,
+  getRandomResponse
+};

package/lib/ai-tools/detector.js

@@ -0,0 +1,76 @@
+const { getAllTools, getToolVersion } = require('./registry');
+const logger = require('../utils/logger');
+
+// Detect all installed AI tools
+async function detectInstalledTools() {
+  const allTools = getAllTools();
+  const installedTools = [];
+
+  logger.debug('Detecting installed AI tools...');
+
+  for (const tool of allTools) {
+    // Skip demo mode from auto-detection (only available via --ai demo)
+    if (tool.key === 'demo') {
+      continue;
+    }
+
+    try {
+      const isInstalled = await tool.checkInstalled();
+
+      if (isInstalled) {
+        const version = await getToolVersion(tool);
+
+        // Always use short command name - PTY will have npm bin in PATH
+        installedTools.push({
+          ...tool,
+          version,
+          installed: true
+        });
+
+        logger.debug(`Found: ${tool.displayName} v${version} (command: ${tool.command})`);
+      }
+    } catch (err) {
+      logger.debug(`Check failed for ${tool.displayName}: ${err.message}`);
+    }
+  }
+
+  logger.debug(`Detected ${installedTools.length} installed AI tools`);
+
+  return installedTools;
+}
+
+// Check if specific tool is installed
+async function isToolInstalled(toolKey) {
+  const { getToolByKey } = require('./registry');
+  const tool = getToolByKey(toolKey);
+
+  if (!tool) {
+    return { installed: false, error: 'Unknown tool' };
+  }
+
+  try {
+    const isInstalled = await tool.checkInstalled();
+
+    if (isInstalled) {
+      const version = await getToolVersion(tool);
+
+      // Always use short command name - PTY will have npm bin in PATH
+      return {
+        installed: true,
+        tool: {
+          ...tool,
+          version
+        }
+      };
+    }
+
+    return { installed: false, tool };
+  } catch (err) {
+    return { installed: false, tool, error: err.message };
+  }
+}
+
+module.exports = {
+  detectInstalledTools,
+  isToolInstalled
+};

package/lib/ai-tools/registry.js

@@ -0,0 +1,300 @@
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const execAsync = promisify(exec);
+const logger = require('../utils/logger');
+
+function preview(text, maxChars = 500) {
+  const value = String(text || '')
+    .replace(/\r/g, '\\r')
+    .replace(/\n/g, '\\n')
+    .replace(/\t/g, '\\t')
+    .replace(/\x1b/g, '\\x1b');
+  return value.length > maxChars ? value.slice(0, maxChars) + '...' : value;
+}
+
+// AI Tools Registry
+const AI_TOOLS = {
+  'claude-code': {
+    key: 'claude-code',
+    command: 'claude',
+    args: [],
+    displayName: 'Claude',
+    description: 'Anthropic\'s AI coding assistant',
+    website: 'https://docs.claude.com',
+    checkInstalled: async () => await commandExists('claude')
+  },
+  'aider': {
+    key: 'aider',
+    command: 'aider',
+    args: [],
+    displayName: 'Aider',
+    description: 'AI pair programming in your terminal',
+    website: 'https://aider.chat',
+    checkInstalled: async () => await commandExists('aider')
+  },
+  'codex': {
+    key: 'codex',
+    command: 'codex',
+    args: [],
+    displayName: 'Codex',
+    description: 'Official OpenAI Codex CLI (launched April 2025)',
+    website: 'https://openai.com/codex',
+    checkInstalled: async () => await commandExists('codex')
+  },
+  'github-copilot': {
+    key: 'github-copilot',
+    command: 'copilot',
+    args: [],
+    displayName: 'Copilot',
+    description: 'GitHub\'s command line AI',
+    website: 'https://github.com/features/copilot',
+    checkInstalled: async () => await commandExists('copilot')
+  },
+  'cody': {
+    key: 'cody',
+    command: 'cody',
+    args: ['chat'],
+    displayName: 'Cody',
+    description: 'Sourcegraph\'s AI assistant (Beta)',
+    website: 'https://sourcegraph.com/cody',
+    checkInstalled: async () => await commandExists('cody')
+  },
+  'gemini': {
+    key: 'gemini',
+    command: 'gemini',
+    args: [],
+    displayName: 'Gemini',
+    description: 'Official Google Gemini CLI with 1M token context',
+    website: 'https://developers.google.com/gemini-code-assist',
+    checkInstalled: async () => await commandExists('gemini')
+  },
+  'continue': {
+    key: 'continue',
+    command: 'cn',
+    args: [],
+    displayName: 'Continue',
+    description: 'Open-source modular AI coding assistant',
+    website: 'https://continue.dev',
+    checkInstalled: async () => await commandExists('cn')
+  },
+  'cursor': {
+    key: 'cursor',
+    command: 'cursor-agent',
+    args: [],
+    displayName: 'Cursor',
+    description: 'Cursor\'s AI coding assistant CLI (Beta)',
+    website: 'https://cursor.com/blog/cli',
+    checkInstalled: async () => await commandExists('cursor-agent')
+  },
+  'chatgpt': {
+    key: 'chatgpt',
+    command: 'chatgpt',
+    args: [],
+    displayName: 'ChatGPT',
+    description: 'ChatGPT in your terminal (Go implementation)',
+    website: 'https://github.com/j178/chatgpt',
+    checkInstalled: async () => await commandExists('chatgpt')
+  },
+  'sgpt': {
+    key: 'sgpt',
+    command: 'sgpt',
+    args: ['--repl', 'temp'],
+    displayName: 'ShellGPT',
+    description: 'ChatGPT-powered shell assistant with REPL mode',
+    website: 'https://github.com/TheR1D/shell_gpt',
+    checkInstalled: async () => await commandExists('sgpt')
+  },
+  'mentat': {
+    key: 'mentat',
+    command: 'mentat',
+    args: [],
+    displayName: 'Mentat',
+    description: 'AI coding assistant with Git integration',
+    website: 'https://www.mentat.ai',
+    checkInstalled: async () => await commandExists('mentat')
+  },
+  'grok': {
+    key: 'grok',
+    command: 'grok',
+    args: [],
+    displayName: 'Grok',
+    description: 'xAI\'s Grok AI assistant (by Elon Musk)',
+    website: 'https://grok.x.ai',
+    checkInstalled: async () => await commandExists('grok')
+  },
+  'ollama': {
+    key: 'ollama',
+    command: 'ollama',
+    args: ['run', 'codellama'],
+    displayName: 'Ollama',
+    description: 'Run LLMs locally (CodeLlama, Llama, etc)',
+    website: 'https://ollama.ai',
+    checkInstalled: async () => await commandExists('ollama')
+  },
+  'openhands': {
+    key: 'openhands',
+    command: 'openhands',
+    args: [],
+    displayName: 'OpenHands',
+    description: 'Open-source AI software engineer (formerly OpenDevin)',
+    website: 'https://github.com/All-Hands-AI/OpenHands',
+    checkInstalled: async () => await commandExists('openhands')
+  },
+  'opencode': {
+    key: 'opencode',
+    command: 'opencode',
+    args: [],
+    displayName: 'OpenCode',
+    description: 'Open-source AI coding agent with LSP integration and 75+ LLM providers',
+    website: 'https://opencode.ai',
+    checkInstalled: async () => await commandExists('opencode')
+  },
+  'blackbox': {
+    key: 'blackbox',
+    command: 'blackboxai',
+    args: [],
+    displayName: 'Blackbox AI',
+    description: 'AI coding assistant with debugging & file editing',
+    website: 'https://blackbox.ai',
+    checkInstalled: async () => await commandExists('blackboxai')
+  },
+  'amazon-q': {
+    key: 'amazon-q',
+    command: 'q',
+    args: [],
+    displayName: 'Amazon Q',
+    description: 'AWS\'s AI coding companion with free tier',
+    website: 'https://aws.amazon.com/q/developer',
+    checkInstalled: async () => await commandExists('q')
+  },
+  'pi': {
+    key: 'pi',
+    command: 'pi',
+    args: [],
+    displayName: 'Pi',
+    description: 'Minimal AI coding agent with extensions, skills, and 15+ LLM providers',
+    website: 'https://shittycodingagent.ai',
+    checkInstalled: async () => await commandExists('pi')
+  },
+  'kilo': {
+    key: 'kilo',
+    command: 'kilo',
+    args: [],
+    displayName: 'Kilo',
+    description: 'Agentic engineering CLI with 500+ models and parallel mode',
+    website: 'https://kilo.ai',
+    checkInstalled: async () => await commandExists('kilo')
+  },
+  'qodercli': {
+    key: 'qodercli',
+    command: 'qodercli',
+    args: [],
+    displayName: 'Qoder',
+    description: 'Qoder AI coding assistant with interactive CLI',
+    website: 'https://qoder.com',
+    checkInstalled: async () => await commandExists('qodercli')
+  },
+  'demo': {
+    key: 'demo',
+    command: 'node',
+    args: [require('path').join(__dirname, 'demo', 'index.js')],
+    displayName: 'Demo',
+    description: 'Interactive demo for testing (no AI installation required)',
+    website: 'https://gitee.com/next2012/glad',
+    checkInstalled: async () => true // Always available
+  }
+};
+
+// Check if command exists
+async function commandExists(command) {
+  try {
+    const isWindows = process.platform === 'win32';
+    const checkCommand = isWindows ? `where ${command}` : `command -v ${command}`;
+    const { stdout, stderr } = await execAsync(checkCommand, { timeout: 5000 });
+    logger.debugInfo(`[tool-detect] command exists: ${command}; stdout="${preview(stdout)}"; stderr="${preview(stderr)}"`);
+    return true;
+  } catch (err) {
+    logger.debugInfo(`[tool-detect] command missing: ${command}; error="${preview(err.message)}"; stdout="${preview(err.stdout)}"; stderr="${preview(err.stderr)}"`);
+    return false;
+  }
+}
+
+// Get tool version
+async function getToolVersion(tool) {
+  // Try --version first
+  try {
+    const { stdout, stderr } = await execAsync(`${tool.command} --version 2>&1`, { timeout: 8000 });
+    logger.debugInfo(`[tool-version] ${tool.displayName} --version stdout="${preview(stdout)}"; stderr="${preview(stderr)}"`);
+    const version = parseVersion(stdout);
+    if (version !== 'unknown') {
+      return version;
+    }
+  } catch (err) {
+    logger.debugInfo(`[tool-version] ${tool.displayName} --version failed: ${preview(err.message)}; stdout="${preview(err.stdout)}"; stderr="${preview(err.stderr)}"`);
+    // Ignore error, will try -v next
+  }
+
+  // Try -v as fallback
+  try {
+    const { stdout, stderr } = await execAsync(`${tool.command} -v 2>&1`, { timeout: 8000 });
+    logger.debugInfo(`[tool-version] ${tool.displayName} -v stdout="${preview(stdout)}"; stderr="${preview(stderr)}"`);
+    const version = parseVersion(stdout);
+    logger.debugInfo(`[tool-version] ${tool.displayName} parsed version="${version}"`);
+    return version;
+  } catch (err) {
+    logger.debugInfo(`[tool-version] ${tool.displayName} -v failed: ${preview(err.message)}; stdout="${preview(err.stdout)}"; stderr="${preview(err.stderr)}"`);
+    return 'unknown';
+  }
+}
+
+// Parse version from output
+function parseVersion(output) {
+  const versionMatch = output.match(/(\d+\.\d+\.\d+)/);
+  if (versionMatch) {
+    return versionMatch[1];
+  }
+
+  const simpleMatch = output.match(/(\d+\.\d+)/);
+  if (simpleMatch) {
+    return simpleMatch[1];
+  }
+
+  return 'unknown';
+}
+
+// Get tool by key
+function getToolByKey(key) {
+  // Normalize key
+  const normalizedKey = key.toLowerCase().replace(/\s+/g, '-');
+
+  // Try exact match
+  if (AI_TOOLS[normalizedKey]) {
+    return AI_TOOLS[normalizedKey];
+  }
+
+  // Try fuzzy match
+  for (const [toolKey, tool] of Object.entries(AI_TOOLS)) {
+    if (tool.displayName.toLowerCase() === key.toLowerCase()) {
+      return tool;
+    }
+    if (tool.command === key) {
+      return tool;
+    }
+  }
+
+  return null;
+}
+
+// Get all tools
+function getAllTools() {
+  return Object.values(AI_TOOLS);
+}
+
+module.exports = {
+  AI_TOOLS,
+  commandExists,
+  getToolVersion,
+  parseVersion,
+  getToolByKey,
+  getAllTools
+};

package/lib/commands/config.js

@@ -0,0 +1,78 @@
+const chalk = require('chalk');
+const { getConfig, setConfig, getConfigPath } = require('../config/manager');
+const logger = require('../utils/logger');
+
+async function configShowCommand() {
+  const config = getConfig();
+
+  console.log(chalk.bold('Glad Configuration:'));
+  console.log('');
+  console.log(chalk.bold.cyan('User Settings:'));
+  console.log(`  Default AI:     ${config.defaultAI || '(auto-detect)'}`);
+  console.log('');
+  console.log(chalk.bold.cyan('System:'));
+  console.log(`  Config file:    ${chalk.gray(getConfigPath())}`);
+  console.log(`  Last updated:   ${config.lastUpdated || 'Never'}`);
+  console.log('');
+  console.log(`To change settings: ${chalk.cyan('glad config set <key> <value>')}`);
+}
+
+async function configGetCommand(key) {
+  if (!key) {
+    return configShowCommand();
+  }
+
+  const value = getConfig(key);
+
+  if (value === undefined) {
+    console.error(chalk.red(`Unknown config key: ${key}`));
+    console.error('');
+    console.error('Available keys: defaultAI');
+    return;
+  }
+
+  console.log(value);
+}
+
+async function configSetCommand(key, value) {
+  if (!key || !value) {
+    console.error(chalk.red('Usage: glad config set <key> <value>'));
+    console.error('');
+    console.error('Examples:');
+    console.error(chalk.cyan('  glad config set defaultAI aider'));
+    return;
+  }
+
+  const validKeys = ['defaultAI'];
+
+  if (!validKeys.includes(key)) {
+    console.error(chalk.red(`Invalid config key: ${key}`));
+    console.error('');
+    console.error(`Valid keys: ${validKeys.join(', ')}`);
+    return;
+  }
+
+  setConfig(key, value);
+  logger.success(`Config updated: ${key} = ${value}`);
+}
+
+async function configCommand(action, key, value) {
+  if (!action) {
+    return configShowCommand();
+  }
+
+  switch (action) {
+    case 'get':
+      await configGetCommand(key);
+      break;
+
+    case 'set':
+      await configSetCommand(key, value);
+      break;
+
+    default:
+      await configGetCommand(action);
+  }
+}
+
+module.exports = configCommand;

package/lib/commands/tools.js

@@ -0,0 +1,128 @@
+const chalk = require('chalk');
+const { getAllTools, getToolByKey } = require('../ai-tools/registry');
+const { detectInstalledTools } = require('../ai-tools/detector');
+
+async function toolsListCommand() {
+  console.log(chalk.bold('Available AI Tools:'));
+  console.log('');
+
+  const allTools = getAllTools();
+  const installedTools = await detectInstalledTools();
+
+  const installedKeys = new Set(installedTools.map(t => t.key));
+
+  for (const tool of allTools) {
+    // Skip demo mode from tools list (it's a special hidden mode)
+    if (tool.key === 'demo') {
+      continue;
+    }
+
+    const isInstalled = installedKeys.has(tool.key);
+    const icon = isInstalled ? chalk.green('✓') : chalk.red('✗');
+    const status = isInstalled ? chalk.green('installed') : chalk.gray('not installed');
+
+    const installedTool = installedTools.find(t => t.key === tool.key);
+    const version = installedTool ? ` v${installedTool.version}` : '';
+
+    console.log(`  ${icon} ${chalk.bold(tool.displayName)} (${tool.command})${version} - ${status}`);
+  }
+
+  console.log('');
+  console.log(`Use ${chalk.cyan('glad')} and choose a tool from the Web UI, or start Glad in your target directory`);
+}
+
+async function toolsDetectCommand() {
+  console.log(chalk.bold('🔍 Detecting installed AI tools...'));
+  console.log('');
+
+  const installedTools = await detectInstalledTools();
+
+  if (installedTools.length === 0) {
+    console.log(chalk.yellow('No AI tools found'));
+    console.log('');
+    console.log('Install an AI coding assistant:');
+    console.log('  • Claude Code: https://docs.claude.com');
+    console.log('  • Aider: pip install aider-chat');
+    console.log('  • GitHub Copilot: gh extension install github/gh-copilot');
+    return;
+  }
+
+  console.log(chalk.green(`Found ${installedTools.length} AI tool${installedTools.length > 1 ? 's' : ''}:`));
+  console.log('');
+
+  installedTools.forEach(tool => {
+    console.log(`  • ${chalk.bold(tool.displayName)} v${tool.version}`);
+  });
+
+  console.log('');
+  if (installedTools.length === 1) {
+    console.log(chalk.cyan(`Recommended: ${installedTools[0].displayName}`));
+  }
+}
+
+async function toolsInfoCommand(toolName) {
+  if (!toolName) {
+    console.error(chalk.red('Please specify a tool name'));
+    console.error('');
+    console.error(`Usage: ${chalk.cyan('glad tools info <tool-name>')}`);
+    return;
+  }
+
+  const tool = getToolByKey(toolName);
+
+  if (!tool) {
+    console.error(chalk.red(`Unknown tool: ${toolName}`));
+    console.error('');
+    console.error(`Use ${chalk.cyan('glad tools list')} to see available tools`);
+    return;
+  }
+
+  console.log(chalk.bold(tool.displayName));
+  console.log('─'.repeat(tool.displayName.length));
+  console.log(`${chalk.gray('Command:')}     ${tool.command}`);
+  console.log(`${chalk.gray('Description:')} ${tool.description}`);
+  console.log(`${chalk.gray('Website:')}     ${tool.website}`);
+
+  const { isToolInstalled } = require('../ai-tools/detector');
+  const result = await isToolInstalled(tool.key);
+
+  if (result.installed) {
+    console.log(`${chalk.gray('Installed:')}   ${chalk.green('✓ Yes')} (v${result.tool.version})`);
+  } else {
+    console.log(`${chalk.gray('Installed:')}   ${chalk.red('✗ No')}`);
+  }
+
+  console.log('');
+  console.log(chalk.bold('Example usage:'));
+  console.log(chalk.cyan(`  glad`));
+
+  if (tool.key === 'aider') {
+    console.log(chalk.cyan('  glad /path/to/project'));
+  }
+}
+
+async function toolsCommand(action, toolName) {
+  switch (action) {
+    case 'list':
+      await toolsListCommand();
+      break;
+
+    case 'detect':
+      await toolsDetectCommand();
+      break;
+
+    case 'info':
+      await toolsInfoCommand(toolName);
+      break;
+
+    default:
+      console.error(chalk.red(`Unknown action: ${action}`));
+      console.error('');
+      console.error('Available actions:');
+      console.error(chalk.cyan('  glad tools list'));
+      console.error(chalk.cyan('  glad tools detect'));
+      console.error(chalk.cyan('  glad tools info <tool-name>'));
+  }
+}
+
+module.exports = toolsCommand;