glad-web 1.0.46 → 2.0.1

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

@@ -1,88 +0,0 @@
-// 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

@@ -1,76 +0,0 @@
-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

@@ -1,300 +0,0 @@
-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')
-  },
-  'antigravity': {
-    key: 'antigravity',
-    command: 'agy',
-    args: [],
-    displayName: 'Antigravity',
-    description: 'Google Antigravity CLI for local agentic coding workflows',
-    website: 'https://antigravity.google/docs/cli-overview',
-    checkInstalled: async () => await commandExists('agy')
-  },
-  '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/anonymous/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/claude/cli-usage.js

@@ -1,95 +0,0 @@
-function stripTerminalFormatting(value) {
-  return String(value || '')
-    .replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '')
-    .replace(/\r/g, '');
-}
-
-function parseTokenCount(value) {
-  const text = String(value || '').trim().replace(/,/g, '');
-  const match = text.match(/^([\d.]+)\s*([kmb])?$/i);
-  if (!match) return null;
-  const amount = Number(match[1]);
-  if (!Number.isFinite(amount)) return null;
-  const multiplier = { k: 1_000, m: 1_000_000, b: 1_000_000_000 }[String(match[2] || '').toLowerCase()] || 1;
-  return Math.round(amount * multiplier);
-}
-
-function parseClaudeUsageOutput(output) {
-  const text = stripTerminalFormatting(output);
-  const cost = text.match(/Total cost:\s*\$([\d,.]+)/i);
-  const apiDuration = text.match(/Total duration \(API\):\s*([^\n]+)/i);
-  const wallDuration = text.match(/Total duration \(wall\):\s*([^\n]+)/i);
-  const codeChanges = text.match(/Total code changes:\s*([\d,]+) lines added,\s*([\d,]+) lines removed/i);
-  const tokens = text.match(/Usage:\s*([\d,.kmb]+) input,\s*([\d,.kmb]+) output,\s*([\d,.kmb]+) cache read,\s*([\d,.kmb]+) cache write/i);
-  const models = [];
-  const modelPattern = /^\s*(.+?):\s*([\d,.kmb]+) input,\s*([\d,.kmb]+) output,\s*([\d,.kmb]+) cache read,\s*([\d,.kmb]+) cache write(?:\s*\(\$([\d,.]+)\))?\s*$/gim;
-  for (const match of text.matchAll(modelPattern)) {
-    if (/^Usage$/i.test(match[1].trim())) continue;
-    models.push({
-      model: match[1].trim(),
-      inputTokens: parseTokenCount(match[2]),
-      outputTokens: parseTokenCount(match[3]),
-      cacheReadTokens: parseTokenCount(match[4]),
-      cacheWriteTokens: parseTokenCount(match[5]),
-      costUsd: match[6] ? Number(match[6].replace(/,/g, '')) : null
-    });
-  }
-
-  if (!cost && !apiDuration && !wallDuration && !codeChanges && !tokens && models.length === 0) {
-    throw new Error('Claude CLI returned an unrecognized /usage response');
-  }
-
-  const totalModelValue = key => models.length > 0
-    ? models.reduce((sum, model) => sum + Number(model[key] || 0), 0)
-    : null;
-
-  return {
-    totalCostUsd: cost ? Number(cost[1].replace(/,/g, '')) : null,
-    apiDuration: apiDuration ? apiDuration[1].trim() : null,
-    wallDuration: wallDuration ? wallDuration[1].trim() : null,
-    linesAdded: codeChanges ? Number(codeChanges[1].replace(/,/g, '')) : null,
-    linesRemoved: codeChanges ? Number(codeChanges[2].replace(/,/g, '')) : null,
-    inputTokens: tokens ? parseTokenCount(tokens[1]) : totalModelValue('inputTokens'),
-    outputTokens: tokens ? parseTokenCount(tokens[2]) : totalModelValue('outputTokens'),
-    cacheReadTokens: tokens ? parseTokenCount(tokens[3]) : totalModelValue('cacheReadTokens'),
-    cacheWriteTokens: tokens ? parseTokenCount(tokens[4]) : totalModelValue('cacheWriteTokens'),
-    models
-  };
-}
-
-function parseClaudeContextOutput(output) {
-  const text = stripTerminalFormatting(output);
-  const model = text.match(/^\*\*Model:\*\*\s*(.+?)\s*$/mi);
-  const tokens = text.match(/^\*\*Tokens:\*\*\s*([\d,.]+\s*[kmb]?)\s*\/\s*([\d,.]+\s*[kmb]?)\s*\(([\d.]+)%\)/mi);
-  if (!tokens) throw new Error('Claude CLI returned an unrecognized /context response');
-
-  const usedTokens = parseTokenCount(tokens[1]);
-  const maxTokens = parseTokenCount(tokens[2]);
-  const categories = [];
-  for (const line of text.split('\n')) {
-    const columns = line.split('|').slice(1, -1).map(value => value.trim());
-    if (columns.length < 3 || !columns[0] || /^category$/i.test(columns[0]) || /^-+$/.test(columns[0])) continue;
-    const categoryTokens = parseTokenCount(columns[1]);
-    if (categoryTokens == null || !/^<?[\d.]+%$/.test(columns[2])) continue;
-    categories.push({
-      label: columns[0].replace(/\*\*/g, ''),
-      tokens: categoryTokens,
-      percent: columns[2]
-    });
-  }
-
-  return {
-    model: model ? model[1].trim() : null,
-    usedTokens,
-    maxTokens,
-    usedPercent: Number(tokens[3]),
-    remainingTokens: usedTokens == null || maxTokens == null ? null : Math.max(0, maxTokens - usedTokens),
-    categories
-  };
-}
-
-module.exports = {
-  parseClaudeContextOutput,
-  parseClaudeUsageOutput,
-  parseTokenCount
-};

package/lib/claude/config.js

@@ -1,82 +0,0 @@
-const MODEL_ALIASES = new Set(['default', 'env', 'sonnet', 'opus', 'haiku']);
-const EFFORT_LEVELS = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
-
-function cleanEnvValue(value) {
-  const text = String(value || '').trim();
-  return text || null;
-}
-
-function readClaudeEnv(env = process.env) {
-  return {
-    anthropicModel: cleanEnvValue(env.ANTHROPIC_MODEL),
-    sonnetModel: cleanEnvValue(env.ANTHROPIC_DEFAULT_SONNET_MODEL),
-    opusModel: cleanEnvValue(env.ANTHROPIC_DEFAULT_OPUS_MODEL),
-    haikuModel: cleanEnvValue(env.ANTHROPIC_DEFAULT_HAIKU_MODEL),
-    subagentModel: cleanEnvValue(env.CLAUDE_CODE_SUBAGENT_MODEL),
-    effort: normalizeEffort(env.CLAUDE_CODE_EFFORT_LEVEL)
-  };
-}
-
-function normalizeModel(value, env = process.env) {
-  const model = String(value || '').trim();
-  if (model) return model;
-  return readClaudeEnv(env).anthropicModel ? 'env' : 'sonnet';
-}
-
-function normalizeEffort(value, env = process.env) {
-  const effort = String(value || '').trim().toLowerCase();
-  if (EFFORT_LEVELS.has(effort)) return effort;
-  const envEffort = String(env.CLAUDE_CODE_EFFORT_LEVEL || '').trim().toLowerCase();
-  return EFFORT_LEVELS.has(envEffort) ? envEffort : 'medium';
-}
-
-function resolveClaudeModel(value, env = process.env) {
-  const selected = normalizeModel(value, env);
-  const config = readClaudeEnv(env);
-  if (selected === 'default') return undefined;
-  if (selected === 'env') return config.anthropicModel || undefined;
-  if (selected === 'sonnet') return config.sonnetModel || 'sonnet';
-  if (selected === 'opus') return config.opusModel || 'opus';
-  if (selected === 'haiku') return config.haikuModel || 'haiku';
-  return selected;
-}
-
-function modelOption(value, label, resolved, source) {
-  return {
-    value,
-    label,
-    resolved: resolved || null,
-    source
-  };
-}
-
-function getClaudeRuntimeConfig(env = process.env) {
-  const config = readClaudeEnv(env);
-  const options = [
-    modelOption('default', 'Default', null, 'Claude default')
-  ];
-  if (config.anthropicModel) {
-    options.push(modelOption('env', 'Env', config.anthropicModel, 'ANTHROPIC_MODEL'));
-  }
-  options.push(
-    modelOption('sonnet', 'Sonnet', config.sonnetModel || 'sonnet', 'ANTHROPIC_DEFAULT_SONNET_MODEL'),
-    modelOption('opus', 'Opus', config.opusModel || 'opus', 'ANTHROPIC_DEFAULT_OPUS_MODEL'),
-    modelOption('haiku', 'Haiku', config.haikuModel || 'haiku', 'ANTHROPIC_DEFAULT_HAIKU_MODEL')
-  );
-
-  return {
-    defaultModel: config.anthropicModel ? 'env' : 'sonnet',
-    defaultEffort: config.effort,
-    models: options,
-    env: config
-  };
-}
-
-module.exports = {
-  EFFORT_LEVELS,
-  MODEL_ALIASES,
-  getClaudeRuntimeConfig,
-  normalizeEffort,
-  normalizeModel,
-  resolveClaudeModel
-};