ai-summon 0.0.1

package/dist/util.js

@@ -0,0 +1,109 @@
+import { readFileSync, existsSync, readdirSync, mkdirSync, writeFileSync } from 'fs';
+import { join, basename } from 'path';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { homedir } from 'os';
+import chalk from 'chalk';
+export const getPackageJson = () => {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const packageJson = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
+    return packageJson;
+};
+export const getConfigPath = () => {
+    const dir = join(homedir(), '.ai');
+    mkdirSync(dir, { recursive: true });
+    return join(dir, 'config.json');
+};
+export const readConfig = () => {
+    const configPath = getConfigPath();
+    if (!existsSync(configPath)) {
+        console.log(chalk.yellow(`Configuration file not found: ${configPath}\n` +
+            `Run "ai init" to create it and set your workingDirectory.`));
+        process.exit(1);
+    }
+    const configContent = readFileSync(configPath, 'utf-8');
+    const config = JSON.parse(configContent);
+    // If workingDirectory is configured but repos/yiren are not, initialize them
+    if (config.workingDirectory && !config.repos) {
+        return {
+            workingDirectory: config.workingDirectory,
+            repos: {},
+            yiren: config.yiren || {},
+            urls: config.urls,
+            urlGroups: config.urlGroups,
+        };
+    }
+    return config;
+};
+const ensureAiDir = () => {
+    const dir = join(homedir(), '.ai');
+    mkdirSync(dir, { recursive: true });
+    return dir;
+};
+const getIdeReposCachePath = () => {
+    const dir = ensureAiDir();
+    return join(dir, 'ide-repos-cache.json');
+};
+export const readIdeReposCache = (workingDirectory) => {
+    const cachePath = getIdeReposCachePath();
+    if (!existsSync(cachePath))
+        return null;
+    try {
+        const raw = readFileSync(cachePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== 1)
+            return null;
+        if (parsed.workingDirectory !== workingDirectory)
+            return null;
+        if (!Array.isArray(parsed.repos))
+            return null;
+        return parsed.repos;
+    }
+    catch {
+        return null;
+    }
+};
+export const writeIdeReposCache = (workingDirectory, repos) => {
+    const cachePath = getIdeReposCachePath();
+    const payload = {
+        version: 1,
+        workingDirectory,
+        updatedAt: Date.now(),
+        repos,
+    };
+    writeFileSync(cachePath, JSON.stringify(payload, null, 2), 'utf-8');
+};
+export const findGitRepositories = (workingDirectory) => {
+    const repositories = [];
+    const scanDirectory = (dir, topLevelFolder = '/') => {
+        try {
+            // Check if current directory contains .git folder
+            if (existsSync(join(dir, '.git'))) {
+                repositories.push({
+                    name: basename(dir),
+                    path: dir,
+                    topLevelFolder,
+                });
+                return; // Stop recursing into this directory
+            }
+            // Continue scanning subdirectories
+            const entries = readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    const fullPath = join(dir, entry.name);
+                    // Determine top-level folder for this entry
+                    const isTopLevel = dir === workingDirectory;
+                    const currentTopLevel = isTopLevel ? entry.name : topLevelFolder;
+                    scanDirectory(fullPath, currentTopLevel);
+                }
+            }
+        }
+        catch {
+            // Silently skip directories with permission errors
+            // This will be enhanced in future iterations
+        }
+    };
+    scanDirectory(workingDirectory);
+    return repositories;
+};

package/eslint.config.js

@@ -0,0 +1,47 @@
+import eslint from '@eslint/js';
+import tseslint from '@typescript-eslint/eslint-plugin';
+import tsparser from '@typescript-eslint/parser';
+import prettier from 'eslint-plugin-prettier';
+import prettierConfig from 'eslint-config-prettier';
+import globals from 'globals';
+
+export default [
+  {
+    ignores: ['dist/**', 'node_modules/**', '**/*.js'],
+  },
+  eslint.configs.recommended,
+  {
+    files: ['src/**/*.ts'],
+    languageOptions: {
+      parser: tsparser,
+      parserOptions: {
+        ecmaVersion: 2020,
+        sourceType: 'module',
+        project: './tsconfig.json',
+      },
+      globals: {
+        ...globals.node,
+        $: 'readonly',
+      },
+    },
+    plugins: {
+      '@typescript-eslint': tseslint,
+      prettier: prettier,
+    },
+    rules: {
+      ...tseslint.configs.recommended.rules,
+      ...prettierConfig.rules,
+      'prettier/prettier': 'error',
+      '@typescript-eslint/explicit-function-return-type': 'off',
+      '@typescript-eslint/no-explicit-any': 'warn',
+      '@typescript-eslint/no-unused-vars': [
+        'error',
+        {
+          argsIgnorePattern: '^_',
+          varsIgnorePattern: '^_',
+        },
+      ],
+      'no-console': 'off',
+    },
+  },
+];

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "ai-summon",
+  "version": "0.0.1",
+  "type": "module",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "rm -rf dist && tsc",
+    "build:install": "npm run build && npm uninstall -g && npm install -g",
+    "start": "node dist/bin/ai-summon.js",
+    "dev": "ts-node bin/ai-summon.ts",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\""
+  },
+  "bin": {
+    "ai": "./dist/ai-summon.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "inquirer": "^9.2.15",
+    "inquirer-autocomplete-prompt": "^3.0.1",
+    "log-symbols": "^6.0.0",
+    "ora": "^8.0.1",
+    "zx": "^7.2.3"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.7",
+    "@types/inquirer-autocomplete-prompt": "^3.0.3",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.48.1",
+    "@typescript-eslint/parser": "^8.48.1",
+    "eslint": "^9.39.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "globals": "^16.5.0",
+    "prettier": "^3.7.4",
+    "ts-node": "^10.9.0",
+    "typescript": "^5.0.0"
+  }
+}

package/specs/001-cloud-login-feature/contracts/cloud-command.ts

@@ -0,0 +1,82 @@
+/**
+ * Cloud Command Interface Contract
+ * Defines the CLI command interface for cloud infrastructure access
+ */
+
+export interface CloudLoginOptions {
+  /** Environment to connect to: dev, staging, or prod */
+  env?: 'dev' | 'staging' | 'prod';
+
+  /** Service name to connect to (e.g., todo-mini, wuhan-mall) */
+  service?: string;
+}
+
+export interface CloudLoginCommand {
+  /**
+   * Execute cloud login SSH connection
+   * @param options Command options from CLI
+   * @returns Promise that resolves when SSH session is established or rejects on error
+   */
+  execute(options: CloudLoginOptions): Promise<void>;
+}
+
+/**
+ * Command signature for Commander.js integration
+ * Main command: hsh cloud (with subcommands)
+ * Usage: hsh cloud login --env dev --service todo-mini
+ */
+export interface CloudCommandDefinition {
+  name: 'cloud';
+  description: 'Cloud infrastructure management commands';
+  subcommands: {
+    login: {
+      description: 'SSH into cloud instances based on environment and service';
+      options: {
+        '--env <environment>': 'Environment: dev, staging, or prod';
+        '--service <service>': 'Service name (e.g., todo-mini, wuhan-mall)';
+      };
+      examples: [
+        'hsh cloud login --env dev --service todo-mini',
+        'hsh cloud login --env prod --service wuhan-mall',
+        'hsh cloud login  # Interactive mode with prompts',
+      ];
+    };
+    // Future subcommands can be added here
+    // scp: { ... };
+    // status: { ... };
+  };
+}
+
+/**
+ * Error types that can be thrown during cloud login execution
+ */
+export enum CloudLoginError {
+  CONFIG_NOT_FOUND = 'CONFIG_NOT_FOUND',
+  INVALID_CONFIG = 'INVALID_CONFIG',
+  SERVICE_NOT_FOUND = 'SERVICE_NOT_FOUND',
+  ENVIRONMENT_NOT_FOUND = 'ENVIRONMENT_NOT_FOUND',
+  PRIVATE_KEY_NOT_FOUND = 'PRIVATE_KEY_NOT_FOUND',
+  PRIVATE_KEY_PERMISSIONS = 'PRIVATE_KEY_PERMISSIONS',
+  SSH_CONNECTION_FAILED = 'SSH_CONNECTION_FAILED',
+  NETWORK_UNREACHABLE = 'NETWORK_UNREACHABLE',
+  AUTHENTICATION_FAILED = 'AUTHENTICATION_FAILED',
+}
+
+/**
+ * Structured error information for user feedback
+ */
+export interface CloudLoginErrorInfo {
+  type: CloudLoginError;
+  message: string;
+  suggestion?: string;
+  command?: string;
+}
+
+/**
+ * Configuration validation result
+ */
+export interface ConfigValidationResult {
+  valid: boolean;
+  errors: CloudLoginErrorInfo[];
+  warnings: string[];
+}

package/specs/001-cloud-login-feature/contracts/config-service.ts

@@ -0,0 +1,170 @@
+/**
+ * Configuration Service Interface Contract
+ * Defines the interface for reading and managing hsh configuration
+ */
+
+import { HshConfig, CloudConfig, Environment } from '../data-model';
+
+export interface ConfigService {
+  /**
+   * Read configuration from ~/.ai/config.json
+   * @returns Promise resolving to parsed configuration
+   * @throws Error if file not found or invalid JSON
+   */
+  readConfig(): Promise<HshConfig>;
+
+  /**
+   * Get cloud configuration for specific service and environment
+   * @param service Service name (e.g., todo-mini)
+   * @param environment Environment name (dev, staging, prod)
+   * @returns Cloud configuration or null if not found
+   */
+  getCloudConfig(service: string, environment: Environment): Promise<CloudConfig | null>;
+
+  /**
+   * Get all available services from configuration
+   * @returns Array of service names
+   */
+  getAvailableServices(): Promise<string[]>;
+
+  /**
+   * Get all available environments for a specific service
+   * @param service Service name
+   * @returns Array of environment names
+   */
+  getAvailableEnvironments(service: string): Promise<Environment[]>;
+
+  /**
+   * Validate configuration structure and content
+   * @returns Validation result with errors and warnings
+   */
+  validateConfig(): Promise<ConfigValidationResult>;
+
+  /**
+   * Migrate legacy configuration to new structure
+   * @param legacyConfig Legacy configuration object
+   * @returns Migrated configuration
+   */
+  migrateConfig(legacyConfig: any): HshConfig;
+
+  /**
+   * Check if configuration uses legacy format
+   * @returns True if configuration needs migration
+   */
+  isLegacyConfig(): Promise<boolean>;
+}
+
+/**
+ * SSH Service Interface Contract
+ * Defines the interface for SSH connection management
+ */
+export interface SSHService {
+  /**
+   * Execute SSH connection to specified host
+   * @param ip Target IP address
+   * @param privateKeyFile Path to SSH private key
+   * @param username SSH username (default: root)
+   * @returns Promise that resolves when connection is established
+   */
+  connect(ip: string, privateKeyFile: string, username?: string): Promise<void>;
+
+  /**
+   * Validate SSH private key file
+   * @param privateKeyFile Path to private key file
+   * @returns Promise resolving to validation result
+   */
+  validatePrivateKey(privateKeyFile: string): Promise<{
+    exists: boolean;
+    permissions: string;
+    isValid: boolean;
+    suggestions: string[];
+  }>;
+
+  /**
+   * Test SSH connectivity without establishing full session
+   * @param ip Target IP address
+   * @param privateKeyFile Path to SSH private key
+   * @returns Promise resolving to connectivity test result
+   */
+  testConnectivity(
+    ip: string,
+    privateKeyFile: string
+  ): Promise<{
+    reachable: boolean;
+    authenticated: boolean;
+    latency: number;
+    error?: string;
+  }>;
+}
+
+/**
+ * Prompt Service Interface Contract
+ * Defines the interface for interactive user prompts
+ */
+export interface PromptService {
+  /**
+   * Prompt user to select service when not provided
+   * @param availableServices List of available service names
+   * @returns Selected service name
+   */
+  promptForService(availableServices: string[]): Promise<string>;
+
+  /**
+   * Prompt user to select environment when not provided
+   * @param availableEnvironments List of available environments
+   * @returns Selected environment
+   */
+  promptForEnvironment(availableEnvironments: Environment[]): Promise<Environment>;
+
+  /**
+   * Prompt user for confirmation before connecting to production
+   * @param service Service name
+   * @returns True if user confirms
+   */
+  confirmProductionAccess(service: string): Promise<boolean>;
+
+  /**
+   * Prompt user for missing configuration values
+   * @param missingFields List of missing configuration fields
+   * @returns User-provided configuration values
+   */
+  promptForConfiguration(missingFields: string[]): Promise<Record<string, string>>;
+}
+
+/**
+ * Migration Service Interface Contract
+ * Defines the interface for configuration migration
+ */
+export interface MigrationService {
+  /**
+   * Detect if current configuration needs migration
+   * @returns Migration assessment
+   */
+  assessMigration(): Promise<{
+    needsMigration: boolean;
+    currentVersion: string;
+    targetVersion: string;
+    changes: string[];
+  }>;
+
+  /**
+   * Execute configuration migration
+   * @param backupOriginal Whether to backup original config
+   * @returns Migration result
+   */
+  executeMigration(backupOriginal?: boolean): Promise<{
+    success: boolean;
+    backupPath?: string;
+    errors: string[];
+  }>;
+
+  /**
+   * Rollback migration to previous configuration
+   * @param backupPath Path to backup configuration
+   * @returns Rollback result
+   */
+  rollbackMigration(backupPath: string): Promise<{
+    success: boolean;
+    errors: string[];
+  }>;
+}