ai-summon 0.0.1

package/src/commands/ide/index.ts

@@ -0,0 +1,322 @@
+import inquirer from 'inquirer';
+import 'zx/globals';
+import chalk from 'chalk';
+import inquirerAutocomplete from 'inquirer-autocomplete-prompt';
+import {
+  readConfig,
+  findGitRepositories,
+  readIdeReposCache,
+  writeIdeReposCache,
+  type GitRepository,
+} from '../../util.js';
+import { spawn } from 'child_process';
+import { existsSync } from 'fs';
+
+interface ReposConfig {
+  [key: string]: {
+    [key: string]: string;
+  };
+}
+
+// Register autocomplete prompt
+inquirer.registerPrompt('autocomplete', inquirerAutocomplete);
+
+let reposConfig: ReposConfig;
+let currentCategory: string;
+let workingDirectory: string | undefined;
+let autoDiscoveredRepos: GitRepository[] = [];
+
+async function loadConfig(options?: { refreshReposCache?: boolean }) {
+  const config = readConfig();
+
+  // Check if workingDirectory is configured
+  if (config.workingDirectory) {
+    workingDirectory = config.workingDirectory;
+
+    // Validate that workingDirectory exists
+    if (!existsSync(workingDirectory)) {
+      throw new Error(`Working directory does not exist: ${workingDirectory}`);
+    }
+
+    if (options?.refreshReposCache) {
+      // Force refresh: rescan and overwrite cache
+      autoDiscoveredRepos = findGitRepositories(workingDirectory);
+      writeIdeReposCache(workingDirectory, autoDiscoveredRepos);
+    } else {
+      // Default: use cache if possible (fast path)
+      const cached = readIdeReposCache(workingDirectory);
+      if (cached) {
+        autoDiscoveredRepos = cached;
+      } else {
+        // Warm the cache on first run
+        autoDiscoveredRepos = findGitRepositories(workingDirectory);
+        writeIdeReposCache(workingDirectory, autoDiscoveredRepos);
+      }
+    }
+
+    // Sort alphabetically by name for better UX
+    autoDiscoveredRepos.sort((a, b) => a.name.localeCompare(b.name));
+  } else {
+    // Use manual configuration (existing behavior)
+    reposConfig = config.repos;
+  }
+}
+
+async function searchCategories(_answers: unknown, input = '') {
+  if (!reposConfig) {
+    await loadConfig();
+  }
+  const categories = Object.keys(reposConfig);
+
+  if (!input) {
+    return categories;
+  }
+
+  return categories.filter((category) => category.toLowerCase().includes(input.toLowerCase()));
+}
+
+async function searchProjects(_answers: unknown, input = '') {
+  if (!reposConfig) {
+    await loadConfig();
+  }
+
+  // Get projects for the selected category
+  if (!currentCategory || !reposConfig[currentCategory]) {
+    return [];
+  }
+
+  const projects = Object.entries(reposConfig[currentCategory]).map(([name, path]) => ({
+    name,
+    path,
+    display: `${name} (${path})`,
+  }));
+
+  if (!input) {
+    return projects.map((p) => p.name);
+  }
+
+  const searchTerm = input.toLowerCase();
+  return projects
+    .filter(
+      (project) =>
+        project.name.toLowerCase().includes(searchTerm) ||
+        project.path.toLowerCase().includes(searchTerm)
+    )
+    .map((p) => p.name);
+}
+
+// Flatten all projects with category context for fuzzy search
+function getAllProjects(): Array<{
+  category: string;
+  name: string;
+  path: string;
+  display: string;
+}> {
+  // Auto-discovery mode: use discovered Git repos
+  if (workingDirectory) {
+    return autoDiscoveredRepos.map((repo) => ({
+      category: repo.topLevelFolder,
+      name: repo.name,
+      path: repo.path,
+      display: `${repo.name} (${repo.path})`,
+    }));
+  }
+
+  // Manual configuration mode
+  if (!reposConfig) return [];
+
+  return Object.entries(reposConfig).flatMap(([category, projects]) =>
+    Object.entries(projects).map(([name, path]) => ({
+      category,
+      name,
+      path,
+      display: `${name} (${category})`,
+    }))
+  );
+}
+
+// Single-keyword fuzzy search across all projects
+async function searchAllProjects(_answers: unknown, input = '') {
+  const allProjects = getAllProjects();
+
+  // Filter projects based on search input
+  let filteredProjects = allProjects;
+  if (input) {
+    const keywords = input.toLowerCase().trim().split(/\s+/);
+    filteredProjects = allProjects.filter((project) => {
+      const searchText = `${project.name} ${project.category} ${project.path}`.toLowerCase();
+      return keywords.every((keyword) => searchText.includes(keyword));
+    });
+  }
+
+  // If auto-discovery mode, add category separators
+  if (workingDirectory) {
+    return formatProjectsWithSeparators(filteredProjects);
+  }
+
+  // Manual mode: simple display
+  return filteredProjects.map((p) => ({ name: p.display, value: p }));
+}
+
+// Format projects with top-level folder separators (for auto-discovery mode)
+function formatProjectsWithSeparators(
+  projects: Array<{
+    category: string;
+    name: string;
+    path: string;
+    display: string;
+  }>
+): Array<{ name: string; value?: unknown; disabled?: string }> {
+  // Group projects by category (top-level folder)
+  const grouped = new Map<
+    string,
+    Array<{ category: string; name: string; path: string; display: string }>
+  >();
+
+  projects.forEach((project) => {
+    const category = project.category;
+    if (!grouped.has(category)) {
+      grouped.set(category, []);
+    }
+    grouped.get(category)!.push(project);
+  });
+
+  // Sort categories alphabetically, but put root (/) last
+  const sortedCategories = Array.from(grouped.keys()).sort((a, b) => {
+    if (a === '/') return 1;
+    if (b === '/') return 1;
+    return a.localeCompare(b);
+  });
+
+  // Build result with separators
+  const result: Array<{ name: string; value?: unknown; disabled?: string }> = [];
+
+  sortedCategories.forEach((category) => {
+    const categoryProjects = grouped.get(category)!;
+
+    // Add category separator
+    const categoryLabel = category === '/' ? '/ (root)' : category;
+    result.push({
+      name: `---------  ${categoryLabel}  ---------`,
+      disabled: 'separator',
+    });
+
+    // Add projects in this category
+    categoryProjects.forEach((p) => {
+      result.push({
+        name: `  ${p.display}`,
+        value: p,
+      });
+    });
+  });
+
+  return result;
+}
+
+// Select project using fuzzy search across all categories
+async function selectProjectWithFuzzySearch(
+  searchMode?: string
+): Promise<{ path: string; name: string }> {
+  const answer = await inquirer.prompt([
+    {
+      type: 'autocomplete',
+      name: 'project',
+      message: `Search and select a project${searchMode ? ` (filtering: ${searchMode})` : ''}:`,
+      source: searchAllProjects,
+      pageSize: 15,
+    },
+  ]);
+
+  return {
+    path: answer.project.path,
+    name: answer.project.name,
+  };
+}
+
+// Select project using two-step category then project selection
+async function selectProjectWithTwoStep(): Promise<{ path: string; name: string }> {
+  const categoryAnswer = await inquirer.prompt([
+    {
+      type: 'autocomplete',
+      name: 'category',
+      message: 'Select a category:',
+      source: searchCategories,
+      pageSize: 10,
+    },
+  ]);
+
+  currentCategory = categoryAnswer.category;
+
+  const projectAnswer = await inquirer.prompt([
+    {
+      type: 'autocomplete',
+      name: 'project',
+      message: 'Select a project:',
+      source: searchProjects,
+      pageSize: 10,
+    },
+  ]);
+
+  return {
+    path: reposConfig[currentCategory][projectAnswer.project],
+    name: projectAnswer.project,
+  };
+}
+
+// Launch Claude IDE with proper TTY handling
+async function launchClaude(projectPath: string): Promise<void> {
+  const claudeProcess = spawn('claude', [], {
+    cwd: projectPath,
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    claudeProcess.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Claude process exited with code ${code}`));
+      }
+    });
+    claudeProcess.on('error', (error) => {
+      reject(error);
+    });
+  });
+}
+
+// Launch Cursor or other IDE
+async function launchIDE(ideType: string, projectPath: string, projectName: string): Promise<void> {
+  await $`${ideType} ${projectPath}`;
+  console.log(chalk.green(`Opening ${projectName} in ${ideType}...`));
+}
+
+export const openIDE = async (ideType: 'cursor' | 'claude', searchMode?: string) => {
+  try {
+    await loadConfig();
+
+    // In auto-discovery mode, always use fuzzy search (no categories)
+    const project =
+      workingDirectory || searchMode !== undefined
+        ? await selectProjectWithFuzzySearch(searchMode)
+        : await selectProjectWithTwoStep();
+
+    // Launch IDE based on type
+    if (ideType === 'claude') {
+      await launchClaude(project.path);
+    } else {
+      await launchIDE(ideType, project.path, project.name);
+    }
+  } catch (error) {
+    console.error(chalk.red(`Error opening project in ${ideType}:`, error));
+  }
+};
+
+export const refreshIdeReposCache = async (): Promise<void> => {
+  await loadConfig({ refreshReposCache: true });
+  if (!workingDirectory) {
+    console.log(chalk.yellow('No workingDirectory configured; nothing to refresh.'));
+    return;
+  }
+  console.log(chalk.green('IDE repository cache refreshed.'));
+};

package/src/commands/init.ts

@@ -0,0 +1,64 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { existsSync, writeFileSync, statSync } from 'fs';
+import { getConfigPath } from '../util.js';
+import type { HshConfig } from '../types/index.js';
+
+export async function initConfig(options?: {
+  workingDirectory?: string;
+  force?: boolean;
+}): Promise<void> {
+  const configPath = getConfigPath();
+
+  if (existsSync(configPath) && !options?.force) {
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'overwrite',
+        message: `Config already exists at ${configPath}. Overwrite?`,
+        default: false,
+      },
+    ]);
+
+    if (!overwrite) {
+      console.log(chalk.yellow('Init cancelled.'));
+      return;
+    }
+  }
+
+  const workingDirectory =
+    options?.workingDirectory ??
+    (
+      await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'workingDirectory',
+          message: 'workingDirectory (a folder containing your git repos):',
+          default: process.cwd(),
+          validate: (input: string) => {
+            const value = input.trim();
+            if (!value) return 'workingDirectory is required';
+            if (!existsSync(value)) return `Path does not exist: ${value}`;
+            try {
+              if (!statSync(value).isDirectory()) return `Not a directory: ${value}`;
+            } catch {
+              return `Cannot access path: ${value}`;
+            }
+            return true;
+          },
+          filter: (input: string) => input.trim(),
+        },
+      ])
+    ).workingDirectory;
+
+  const payload: HshConfig = {
+    workingDirectory,
+    repos: {},
+    yiren: {},
+    urls: {},
+    urlGroups: {},
+  };
+
+  writeFileSync(configPath, JSON.stringify(payload, null, 2), 'utf-8');
+  console.log(chalk.green(`✅ Wrote config: ${configPath}`));
+}

package/src/commands/url.ts

@@ -0,0 +1,262 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import inquirerAutocomplete from 'inquirer-autocomplete-prompt';
+import { getConfigPath, readConfig } from '../util.js';
+import { writeFileSync } from 'fs';
+import { HshConfig } from '../types/index.js';
+import { $ } from 'zx';
+
+// Register autocomplete prompt
+inquirer.registerPrompt('autocomplete', inquirerAutocomplete);
+
+// Read and write config helpers
+function readFullConfig(): HshConfig {
+  const config = readConfig();
+  if (!config.urls) {
+    config.urls = {};
+  }
+  return config;
+}
+
+function writeConfig(config: HshConfig): void {
+  // Sort URLs by domain before writing
+  if (config.urls) {
+    const sortedUrls: Record<string, string> = {};
+
+    // Create entries with extracted domains for sorting
+    const entries = Object.entries(config.urls).map(([name, url]) => {
+      // Extract domain from URL
+      let domain = '';
+      try {
+        const urlObj = new URL(url);
+        domain = urlObj.hostname;
+      } catch {
+        // If URL parsing fails, use the URL string itself for sorting
+        domain = url;
+      }
+      return { name, url, domain };
+    });
+
+    // Sort by domain, then by name
+    entries.sort((a, b) => {
+      const domainCompare = a.domain.localeCompare(b.domain);
+      if (domainCompare !== 0) return domainCompare;
+      return a.name.localeCompare(b.name);
+    });
+
+    // Rebuild the urls object with sorted entries
+    for (const entry of entries) {
+      sortedUrls[entry.name] = entry.url;
+    }
+
+    config.urls = sortedUrls;
+  }
+
+  writeFileSync(getConfigPath(), JSON.stringify(config, null, 2), 'utf-8');
+}
+
+// Add a new URL
+export async function addUrl(name: string, url: string): Promise<void> {
+  try {
+    const config = readFullConfig();
+
+    if (config.urls![name]) {
+      console.log(
+        chalk.yellow(`⚠️  URL with name "${name}" already exists: ${config.urls![name]}`)
+      );
+      const answer = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'overwrite',
+          message: 'Do you want to overwrite it?',
+          default: false,
+        },
+      ]);
+
+      if (!answer.overwrite) {
+        console.log(chalk.blue('ℹ️  Operation cancelled.'));
+        return;
+      }
+    }
+
+    config.urls![name] = url;
+    writeConfig(config);
+    console.log(chalk.green(`✅ Added URL: ${name} → ${url}`));
+  } catch (error) {
+    console.error(chalk.red('Error adding URL:'), error);
+  }
+}
+
+// Search URLs and return selected entry
+async function searchUrls(
+  _answers: unknown,
+  input = ''
+): Promise<Array<{ name: string; value: { name: string; url: string } }>> {
+  const config = readFullConfig();
+  const urls = config.urls || {};
+
+  const entries = Object.entries(urls).map(([name, url]) => ({
+    name,
+    url,
+    display: `${name} - ${url}`,
+  }));
+
+  if (!input) {
+    return entries.map((entry) => ({
+      name: entry.display,
+      value: { name: entry.name, url: entry.url },
+    }));
+  }
+
+  // Multi-keyword search: split by spaces and match all keywords
+  const keywords = input.toLowerCase().trim().split(/\s+/);
+  return entries
+    .filter((entry) => {
+      const searchText = `${entry.name} ${entry.url}`.toLowerCase();
+      return keywords.every((keyword) => searchText.includes(keyword));
+    })
+    .map((entry) => ({
+      name: entry.display,
+      value: { name: entry.name, url: entry.url },
+    }));
+}
+
+// Remove a URL
+export async function removeUrl(name?: string): Promise<void> {
+  try {
+    const config = readFullConfig();
+
+    if (!config.urls || Object.keys(config.urls).length === 0) {
+      console.log(chalk.yellow('⚠️  No URLs found in configuration.'));
+      return;
+    }
+
+    let targetName: string;
+
+    if (name) {
+      // Direct removal with name provided
+      if (!config.urls[name]) {
+        console.log(chalk.yellow(`⚠️  URL with name "${name}" not found.`));
+        return;
+      }
+      targetName = name;
+    } else {
+      // Search mode
+      const answer = await inquirer.prompt([
+        {
+          type: 'autocomplete',
+          name: 'selected',
+          message: 'Search and select a URL to remove:',
+          source: searchUrls,
+          pageSize: 15,
+        },
+      ]);
+      targetName = answer.selected.name;
+    }
+
+    const removedUrl = config.urls[targetName];
+    delete config.urls[targetName];
+    writeConfig(config);
+    console.log(chalk.green(`✅ Removed URL: ${targetName} - ${removedUrl}`));
+  } catch (error) {
+    console.error(chalk.red('Error removing URL:'), error);
+  }
+}
+
+// Search and open URL in Chrome
+export async function searchAndOpenUrl(suppress?: boolean): Promise<void> {
+  try {
+    const config = readFullConfig();
+
+    if (!config.urls || Object.keys(config.urls).length === 0) {
+      console.log(chalk.yellow('⚠️  No URLs found in configuration.'));
+      return;
+    }
+
+    const answer = await inquirer.prompt([
+      {
+        type: 'autocomplete',
+        name: 'selected',
+        message: 'Search and select a URL to open:',
+        source: searchUrls,
+        pageSize: 15,
+      },
+    ]);
+
+    const selectedUrl = answer.selected.url;
+    console.log(chalk.blue(`🌐 Opening ${answer.selected.name}: ${selectedUrl}`));
+
+    // Open URL in Chrome (works on macOS, Linux, and Windows)
+    await $`open -a "Google Chrome" ${selectedUrl}`;
+    console.log(chalk.green('✅ URL opened in Chrome'));
+
+    // Auto-dismiss popups if --suppress flag is enabled
+    if (suppress) {
+      console.log(chalk.blue('⏳ Waiting 1s before dismissing popup...'));
+      // Wait 1 second
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+
+      // Use osascript to simulate Enter key press on macOS
+      await $`osascript -e 'tell application "System Events" to keystroke return'`;
+
+      // Wait 1 second
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+
+      // Use osascript to simulate Enter key press on macOS
+      await $`osascript -e 'tell application "System Events" to keystroke return'`;
+      console.log(chalk.green('✅ Popup dismissed with Enter key'));
+    }
+  } catch (error) {
+    console.error(chalk.red('Error opening URL:'), error);
+  }
+}
+
+// Open URL group in a new Chrome window
+export async function openUrlGroup(): Promise<void> {
+  try {
+    const config = readFullConfig();
+
+    if (!config.urlGroups || Object.keys(config.urlGroups).length === 0) {
+      console.log(chalk.yellow('⚠️  No URL groups found in configuration.'));
+      return;
+    }
+
+    const groupNames = Object.keys(config.urlGroups);
+    const answer = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'selectedGroup',
+        message: 'Select a URL group to open:',
+        choices: groupNames,
+      },
+    ]);
+
+    const selectedGroupName = answer.selectedGroup;
+    const urls = config.urlGroups[selectedGroupName];
+
+    if (!urls || urls.length === 0) {
+      console.log(chalk.yellow(`⚠️  No URLs found in group "${selectedGroupName}".`));
+      return;
+    }
+
+    console.log(chalk.blue(`🌐 Opening ${urls.length} URLs from group "${selectedGroupName}"...`));
+
+    // Open all URLs in a new Chrome window
+    // First URL opens in a new window
+    await $`open -na "Google Chrome" --args --new-window ${urls[0]}`;
+
+    // Add a small delay to ensure Chrome window is ready
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    // Open remaining URLs as tabs in the same window
+    for (let i = 1; i < urls.length; i++) {
+      await $`open -a "Google Chrome" ${urls[i]}`;
+      // Small delay between opening tabs to ensure they all load properly
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+
+    console.log(chalk.green(`✅ Opened ${urls.length} URLs in Chrome`));
+  } catch (error) {
+    console.error(chalk.red('Error opening URL group:'), error);
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,49 @@
+export type RepoDirLevel = 'root' | 'client' | 'server';
+
+// Cloud configuration types
+export interface CloudConfig {
+  ip: string;
+  privateKeyFile: string;
+}
+
+export interface ServiceConfig {
+  dev: CloudConfig;
+  staging: CloudConfig;
+  prod: CloudConfig;
+}
+
+export interface YirenConfig {
+  [serviceName: string]: ServiceConfig;
+}
+
+export interface HshConfig {
+  workingDirectory?: string; // Optional working directory for auto-discovery
+  repos: {
+    [groupName: string]: {
+      [repoName: string]: string;
+    };
+  };
+  yiren: YirenConfig;
+  urls?: {
+    [name: string]: string;
+  };
+  urlGroups?: {
+    [groupName: string]: string[];
+  };
+}
+
+export type Environment = 'dev' | 'staging' | 'prod';
+
+// SCP command types
+export interface ScpOptions {
+  env?: Environment;
+  service?: string;
+  recursive?: boolean;
+}
+
+export interface PathValidationResult {
+  exists: boolean;
+  isDirectory: boolean;
+  isFile: boolean;
+  path: string;
+}