ai-summon 0.0.1

package/dist/ai-summon.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { getPackageJson } from './util.js';
+import { openIDE, refreshIdeReposCache } from './commands/ide/index.js';
+import { addUrl, openUrlGroup, removeUrl, searchAndOpenUrl } from './commands/url.js';
+import { initConfig } from './commands/init.js';
+const packageJson = getPackageJson();
+const program = new Command();
+program.usage('<command> [options]');
+program.version(packageJson.version);
+program
+    .command('init')
+    .description('initialize ~/.ai/config.json (prompts for workingDirectory)')
+    .option('-w, --working-directory <path>', 'set workingDirectory without prompting')
+    .option('-f, --force', 'overwrite existing config without confirmation')
+    .action(async (options) => {
+    await initConfig({ workingDirectory: options.workingDirectory, force: options.force });
+});
+const cursor = program.command('cursor').description('open project in Cursor');
+cursor
+    .argument('[search]', 'optional search keyword for fuzzy search')
+    .action(async (search) => {
+    await openIDE('cursor', search);
+});
+cursor
+    .command('refresh')
+    .description('refresh cached auto-discovered repositories (workingDirectory mode)')
+    .action(async () => {
+    await refreshIdeReposCache();
+});
+const claude = program.command('claude').description('open project in Claude');
+claude
+    .argument('[search]', 'optional search keyword for fuzzy search')
+    .action(async (search) => {
+    await openIDE('claude', search);
+});
+claude
+    .command('refresh')
+    .description('refresh cached auto-discovered repositories (workingDirectory mode)')
+    .action(async () => {
+    await refreshIdeReposCache();
+});
+// URL management commands
+const urlCommand = program.command('url').description('URL bookmark management');
+urlCommand
+    .command('add')
+    .description('Add a new URL bookmark')
+    .argument('<name>', 'Name of the URL bookmark')
+    .argument('<url>', 'URL to bookmark')
+    .action(async (name, url) => {
+    await addUrl(name, url);
+});
+urlCommand
+    .command('remove')
+    .description('Remove a URL bookmark')
+    .argument('[name]', 'Name of the URL bookmark to remove (optional, will enter search mode if not provided)')
+    .action(async (name) => {
+    await removeUrl(name);
+});
+urlCommand
+    .command('search')
+    .description('Search and open a URL bookmark in Chrome')
+    .option('--suppress', 'Auto-dismiss popups by simulating Enter key after 1s')
+    .action(async (options) => {
+    await searchAndOpenUrl(options.suppress);
+});
+urlCommand
+    .command('group')
+    .description('Select and open a URL group in a new Chrome window')
+    .action(async () => {
+    await openUrlGroup();
+});
+program.parse();

package/dist/commands/ide/index.d.ts

@@ -0,0 +1,3 @@
+import 'zx/globals';
+export declare const openIDE: (ideType: "cursor" | "claude", searchMode?: string) => Promise<void>;
+export declare const refreshIdeReposCache: () => Promise<void>;

package/dist/commands/ide/index.js

@@ -0,0 +1,253 @@
+import inquirer from 'inquirer';
+import 'zx/globals';
+import chalk from 'chalk';
+import inquirerAutocomplete from 'inquirer-autocomplete-prompt';
+import { readConfig, findGitRepositories, readIdeReposCache, writeIdeReposCache, } from '../../util.js';
+import { spawn } from 'child_process';
+import { existsSync } from 'fs';
+// Register autocomplete prompt
+inquirer.registerPrompt('autocomplete', inquirerAutocomplete);
+let reposConfig;
+let currentCategory;
+let workingDirectory;
+let autoDiscoveredRepos = [];
+async function loadConfig(options) {
+    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, 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, 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() {
+    // 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, 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) {
+    // Group projects by category (top-level folder)
+    const grouped = new Map();
+    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 = [];
+    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) {
+    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() {
+    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) {
+    const claudeProcess = spawn('claude', [], {
+        cwd: projectPath,
+        stdio: 'inherit',
+        shell: true,
+    });
+    await new Promise((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, projectPath, projectName) {
+    await $ `${ideType} ${projectPath}`;
+    console.log(chalk.green(`Opening ${projectName} in ${ideType}...`));
+}
+export const openIDE = async (ideType, searchMode) => {
+    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 () => {
+    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/dist/commands/init.d.ts

@@ -0,0 +1,4 @@
+export declare function initConfig(options?: {
+    workingDirectory?: string;
+    force?: boolean;
+}): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,55 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { existsSync, writeFileSync, statSync } from 'fs';
+import { getConfigPath } from '../util.js';
+export async function initConfig(options) {
+    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) => {
+                    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) => input.trim(),
+            },
+        ])).workingDirectory;
+    const payload = {
+        workingDirectory,
+        repos: {},
+        yiren: {},
+        urls: {},
+        urlGroups: {},
+    };
+    writeFileSync(configPath, JSON.stringify(payload, null, 2), 'utf-8');
+    console.log(chalk.green(`✅ Wrote config: ${configPath}`));
+}

package/dist/commands/url.d.ts

@@ -0,0 +1,4 @@
+export declare function addUrl(name: string, url: string): Promise<void>;
+export declare function removeUrl(name?: string): Promise<void>;
+export declare function searchAndOpenUrl(suppress?: boolean): Promise<void>;
+export declare function openUrlGroup(): Promise<void>;

package/dist/commands/url.js

@@ -0,0 +1,223 @@
+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 { $ } from 'zx';
+// Register autocomplete prompt
+inquirer.registerPrompt('autocomplete', inquirerAutocomplete);
+// Read and write config helpers
+function readFullConfig() {
+    const config = readConfig();
+    if (!config.urls) {
+        config.urls = {};
+    }
+    return config;
+}
+function writeConfig(config) {
+    // Sort URLs by domain before writing
+    if (config.urls) {
+        const sortedUrls = {};
+        // 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, url) {
+    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, input = '') {
+    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) {
+    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;
+        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) {
+    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() {
+    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/dist/types/index.d.ts

@@ -0,0 +1,40 @@
+export type RepoDirLevel = 'root' | 'client' | 'server';
+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;
+    repos: {
+        [groupName: string]: {
+            [repoName: string]: string;
+        };
+    };
+    yiren: YirenConfig;
+    urls?: {
+        [name: string]: string;
+    };
+    urlGroups?: {
+        [groupName: string]: string[];
+    };
+}
+export type Environment = 'dev' | 'staging' | 'prod';
+export interface ScpOptions {
+    env?: Environment;
+    service?: string;
+    recursive?: boolean;
+}
+export interface PathValidationResult {
+    exists: boolean;
+    isDirectory: boolean;
+    isFile: boolean;
+    path: string;
+}

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/util.d.ts

@@ -0,0 +1,16 @@
+import { HshConfig } from './types/index.js';
+export declare const getPackageJson: () => any;
+export declare const getConfigPath: () => string;
+export declare const readConfig: () => HshConfig;
+/**
+ * Recursively scan directory for Git repositories
+ * Returns list of { name, path, topLevelFolder } objects
+ */
+export interface GitRepository {
+    name: string;
+    path: string;
+    topLevelFolder: string;
+}
+export declare const readIdeReposCache: (workingDirectory: string) => GitRepository[] | null;
+export declare const writeIdeReposCache: (workingDirectory: string, repos: GitRepository[]) => void;
+export declare const findGitRepositories: (workingDirectory: string) => GitRepository[];