workplace-pua-cli 0.4.0

package/src/commands/prompt.ts

@@ -0,0 +1,154 @@
+import readline from 'readline';
+import chalk from 'chalk';
+import { Message } from '../llm/base';
+import { getBossSystemMessage, getEmployeeSystemMessage } from '../prompts';
+import { createLLM } from '../llm/factory';
+import { getProviderBaseUrl } from '../config/settings';
+import { StreamPrinter } from '../utils/stream';
+import { OutputFormatter, type OutputFormat } from '../utils/formatter';
+import { logger } from '../utils/logger';
+import { type ProviderType } from '../config/providers';
+
+export interface PromptOptions {
+  apiKey: string;
+  provider: ProviderType;
+  model: string;
+  role: 'boss' | 'employee';
+  severity: 'mild' | 'medium' | 'extreme';
+  input?: string;
+  format?: OutputFormat;
+}
+
+export async function promptCommand(options: PromptOptions): Promise<void> {
+  // Get input from argument or stdin
+  let userInput = options.input;
+
+  if (!userInput) {
+    // Read from stdin if available (pipe mode)
+    if (!process.stdin.isTTY) {
+      userInput = await readFromStdin();
+    }
+  }
+
+  if (!userInput) {
+    logger.error('请提供输入内容');
+    console.log(chalk.gray('用法: pua prompt --role boss "你的问题"'));
+    console.log(chalk.gray('或者: echo "你的问题" | pua prompt --role boss'));
+    process.exit(1);
+  }
+
+  // Set up system message
+  const systemMessage =
+    options.role === 'boss'
+      ? getBossSystemMessage(options.severity)
+      : getEmployeeSystemMessage(options.severity);
+
+  const messages: Message[] = [
+    { role: 'system', content: systemMessage },
+    { role: 'user', content: userInput }
+  ];
+
+  // Create LLM instance
+  const llm = createLLM(options.provider, {
+    apiKey: options.apiKey,
+    model: options.model,
+    baseUrl: getProviderBaseUrl(options.provider),
+  });
+
+  const printer = new StreamPrinter(
+    options.role === 'boss' ? chalk.red : chalk.yellow
+  );
+
+  const formatter = new OutputFormatter(options.format);
+
+  try {
+    const roleLabel = options.role === 'boss' ? '老板' : '员工';
+    console.log();
+    console.log(chalk.gray(`┌─ ${roleLabel} ─────────────────────────────`));
+
+    let fullResponse = '';
+
+    await llm.chatStream(messages, (chunk) => {
+      if (chunk.content) {
+        fullResponse += chunk.content;
+        // 只有在文本格式时才流式输出
+        if (!options.format || options.format === 'text') {
+          process.stdout.write(chunk.content);
+        }
+      }
+    });
+
+    console.log();
+    console.log(chalk.gray('└─────────────────────────────────────'));
+    console.log();
+
+    // 使用格式化器输出
+    if (options.format && options.format !== 'text') {
+      formatter.print({
+        format: options.format,
+        content: fullResponse,
+        metadata: {
+          role: options.role,
+          severity: options.severity,
+          provider: options.provider,
+          model: options.model
+        }
+      });
+    } else {
+      // Print just the response for piping purposes
+      console.log(fullResponse);
+    }
+
+  } catch (error) {
+    printer.printError(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+function readFromStdin(): Promise<string> {
+  return new Promise((resolve) => {
+    let data = '';
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      crlfDelay: Infinity
+    });
+
+    rl.on('line', (line) => {
+      data += line + '\n';
+    });
+
+    rl.on('close', () => {
+      resolve(data.trim());
+    });
+  });
+}
+
+export async function promptBatchCommand(inputs: string[], options: PromptOptions): Promise<void> {
+  // Set up system message
+  const systemMessage =
+    options.role === 'boss'
+      ? getBossSystemMessage(options.severity)
+      : getEmployeeSystemMessage(options.severity);
+
+  // Create LLM instance
+  const llm = createLLM(options.provider, {
+    apiKey: options.apiKey,
+    model: options.model,
+    baseUrl: getProviderBaseUrl(options.provider),
+  });
+
+  for (const input of inputs) {
+    const messages: Message[] = [
+      { role: 'system', content: systemMessage },
+      { role: 'user', content: input }
+    ];
+
+    try {
+      const response = await llm.chat(messages);
+      console.log(response);
+    } catch (error) {
+      logger.error(error instanceof Error ? error.message : String(error));
+    }
+  }
+}

package/src/config/providers.ts

@@ -0,0 +1,109 @@
+export type ProviderType = 'zhipu' | 'openai';
+
+export interface ProviderDefinition {
+  id: ProviderType;
+  name: string;
+  description: string;
+  defaultBaseUrl: string;
+  defaultModels: string[];
+  envKeyNames: string[];
+}
+
+export const PROVIDERS: Record<ProviderType, ProviderDefinition> = {
+  zhipu: {
+    id: 'zhipu',
+    name: '智谱 AI',
+    description: '国产大模型，稳定可靠，响应快速',
+    defaultBaseUrl: '',
+    defaultModels: ['glm-4.7', 'glm-4.7-flash'],
+    envKeyNames: ['ZHIPUAI_API_KEY'],
+  },
+  openai: {
+    id: 'openai',
+    name: 'OpenAI',
+    description: '国际通用，支持 GPT-4o、GPT-4o-mini 等模型',
+    defaultBaseUrl: 'https://api.openai.com/v1',
+    defaultModels: ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'gpt-3.5-turbo'],
+    envKeyNames: ['OPENAI_API_KEY'],
+  },
+};
+
+/**
+ * Get provider definition by ID
+ */
+export function getProvider(id: string): ProviderDefinition | null {
+  return PROVIDERS[id as ProviderType] ?? null;
+}
+
+/**
+ * Get all provider IDs
+ */
+export function getProviderIds(): ProviderType[] {
+  return Object.keys(PROVIDERS) as ProviderType[];
+}
+
+/**
+ * Validate API key format (basic validation)
+ */
+export function validateApiKey(provider: ProviderType, apiKey: string): { valid: boolean; error?: string } {
+  if (!apiKey || apiKey.trim().length === 0) {
+    return { valid: false, error: 'API Key 不能为空' };
+  }
+
+  // Provider-specific validation
+  switch (provider) {
+    case 'zhipu':
+      // 智谱 API key 通常以特定格式开头
+      if (apiKey.length < 10) {
+        return { valid: false, error: '智谱 API Key 格式不正确（太短）' };
+      }
+      break;
+
+    case 'openai':
+      // OpenAI API key 通常以 sk- 开头
+      if (!apiKey.startsWith('sk-')) {
+        return { valid: false, error: 'OpenAI API Key 通常以 sk- 开头' };
+      }
+      if (apiKey.length < 20) {
+        return { valid: false, error: 'OpenAI API Key 格式不正确（太短）' };
+      }
+      break;
+  }
+
+  return { valid: true };
+}
+
+/**
+ * Validate base URL format
+ */
+export function validateBaseUrl(baseUrl: string): { valid: boolean; error?: string } {
+  if (!baseUrl || baseUrl.trim().length === 0) {
+    return { valid: true }; // Empty is OK (will use default)
+  }
+
+  try {
+    const url = new URL(baseUrl);
+    if (url.protocol !== 'https:' && url.protocol !== 'http:') {
+      return { valid: false, error: 'Base URL 必须以 http:// 或 https:// 开头' };
+    }
+    return { valid: true };
+  } catch {
+    return { valid: false, error: 'Base URL 格式不正确' };
+  }
+}
+
+/**
+ * Get API key from environment variables
+ */
+export function getApiKeyFromEnv(provider: ProviderType): string | null {
+  const providerDef = PROVIDERS[provider];
+
+  for (const envKey of providerDef.envKeyNames) {
+    const value = process.env[envKey];
+    if (value) {
+      return value;
+    }
+  }
+
+  return null;
+}

package/src/config/session-storage.ts

@@ -0,0 +1,94 @@
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+
+export interface SessionData {
+  id: string;
+  name: string;
+  description?: string;
+  createdAt: string;
+  updatedAt: string;
+  messages: Array<{ role: string; content: string }>;
+  metadata?: {
+    role?: string;
+    severity?: string;
+    provider?: string;
+    model?: string;
+  };
+}
+
+export class SessionStorage {
+  private sessionsDir: string;
+
+  constructor() {
+    this.sessionsDir = path.join(os.homedir(), '.pua-cli', 'sessions');
+    this.ensureDirectory();
+  }
+
+  private ensureDirectory(): void {
+    if (!fs.existsSync(this.sessionsDir)) {
+      fs.mkdirSync(this.sessionsDir, { recursive: true });
+    }
+  }
+
+  listSessions(): SessionData[] {
+    const files = fs.readdirSync(this.sessionsDir)
+      .filter(f => f.endsWith('.json'));
+
+    return files.map(file => {
+      const filePath = path.join(this.sessionsDir, file);
+      const content = fs.readFileSync(filePath, 'utf-8');
+      return JSON.parse(content);
+    })
+    .sort((a, b) =>
+      new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+    );
+  }
+
+  loadSession(sessionId: string): SessionData | null {
+    const filePath = path.join(this.sessionsDir, `${sessionId}.json`);
+
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return JSON.parse(content);
+  }
+
+  saveSession(sessionData: Omit<SessionData, 'id' | 'createdAt' | 'updatedAt'>): SessionData {
+    const sessionId = this.generateId();
+    const now = new Date().toISOString();
+
+    const fullSession: SessionData = {
+      ...sessionData,
+      id: sessionId,
+      createdAt: now,
+      updatedAt: now
+    };
+
+    const filePath = path.join(this.sessionsDir, `${sessionId}.json`);
+    fs.writeFileSync(filePath, JSON.stringify(fullSession, null, 2));
+
+    return fullSession;
+  }
+
+  deleteSession(sessionId: string): boolean {
+    const filePath = path.join(this.sessionsDir, `${sessionId}.json`);
+
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+      return true;
+    }
+
+    return false;
+  }
+
+  private generateId(): string {
+    return `session-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+  }
+
+  getSessionsDir(): string {
+    return this.sessionsDir;
+  }
+}

package/src/config/settings.ts

@@ -0,0 +1,194 @@
+import dotenv from 'dotenv';
+import path from 'path';
+import {
+  loadGlobalConfig,
+  loadProjectConfig,
+  getProviderApiKey,
+  getCurrentProvider,
+  hasGlobalConfig,
+  type GlobalConfig,
+  type ProjectConfig,
+} from './storage';
+import { getProvider, validateApiKey, getApiKeyFromEnv, type ProviderType } from './providers';
+
+// Load environment variables
+dotenv.config();
+
+export interface RuntimeConfig {
+  apiKey: string;
+  provider: ProviderType;
+  model: string;
+  role: 'boss' | 'employee';
+  severity: 'mild' | 'medium' | 'extreme';
+}
+
+export const DEFAULTS = {
+  provider: 'zhipu' as ProviderType,
+  model: 'glm-4.7',
+  role: 'boss' as 'boss' | 'employee',
+  severity: 'medium' as 'mild' | 'medium' | 'extreme',
+};
+
+/**
+ * Load configuration with priority:
+ * 1. Command line options (highest)
+ * 2. Environment variables
+ * 3. Project config (.pua.json)
+ * 4. Global config (~/.config/pua-cli/config.json)
+ * 5. Defaults (lowest)
+ */
+export function loadConfig(options?: {
+  provider?: ProviderType;
+  model?: string;
+  role?: 'boss' | 'employee';
+  severity?: 'mild' | 'medium' | 'extreme';
+  apiKey?: string;
+}): RuntimeConfig {
+  // Start with defaults
+  let provider = DEFAULTS.provider;
+  let model = DEFAULTS.model;
+  let role = DEFAULTS.role;
+  let severity = DEFAULTS.severity;
+  let apiKey = '';
+
+  // Load global config
+  const globalConfig = loadGlobalConfig();
+
+  // Load project config
+  const projectConfig = loadProjectConfig();
+
+  // Apply global config
+  if (globalConfig) {
+    provider = globalConfig.defaults.provider as ProviderType || provider;
+    model = globalConfig.defaults.model || model;
+    role = globalConfig.defaults.role as 'boss' | 'employee' || role;
+    severity = globalConfig.defaults.severity as 'mild' | 'medium' | 'extreme' || severity;
+    apiKey = globalConfig.providers[globalConfig.currentProvider]?.apiKey || '';
+  }
+
+  // Apply project config
+  if (projectConfig) {
+    if (projectConfig.provider) provider = projectConfig.provider as ProviderType;
+    if (projectConfig.model) model = projectConfig.model;
+    if (projectConfig.role) role = projectConfig.role as 'boss' | 'employee';
+    if (projectConfig.severity) severity = projectConfig.severity as 'mild' | 'medium' | 'extreme';
+  }
+
+  // Apply environment variables
+  const envApiKey = getApiKeyFromEnv(provider);
+  if (envApiKey) {
+    apiKey = envApiKey;
+  }
+
+  // Apply command line options (highest priority)
+  if (options) {
+    if (options.provider) provider = options.provider;
+    if (options.model) model = options.model;
+    if (options.role) role = options.role;
+    if (options.severity) severity = options.severity;
+    if (options.apiKey) apiKey = options.apiKey;
+  }
+
+  // Ensure API key is available
+  if (!apiKey) {
+    throw new MissingApiKeyError(provider);
+  }
+
+  return {
+    apiKey,
+    provider,
+    model,
+    role,
+    severity,
+  };
+}
+
+/**
+ * Error thrown when API key is missing
+ */
+export class MissingApiKeyError extends Error {
+  constructor(provider: ProviderType) {
+    const providerDef = getProvider(provider);
+    const envKey = providerDef?.envKeyNames[0] || 'API_KEY';
+
+    super(
+      `未找到 ${providerDef?.name || provider} 的 API Key\n\n` +
+      `请使用以下方式之一配置：\n` +
+      `  1. 运行: pua config\n` +
+      `  2. 设置环境变量: export ${envKey}="your-api-key"\n` +
+      `  3. 创建 .env 文件并添加: ${envKey}=your-api-key`
+    );
+    this.name = 'MissingApiKeyError';
+  }
+}
+
+/**
+ * Check if user needs onboarding
+ */
+export function needsOnboarding(): boolean {
+  return !hasGlobalConfig();
+}
+
+/**
+ * Get provider's base URL
+ */
+export function getProviderBaseUrl(provider: ProviderType): string {
+  const globalConfig = loadGlobalConfig();
+  const providerConfig = globalConfig?.providers[provider];
+
+  if (providerConfig?.baseUrl) {
+    return providerConfig.baseUrl;
+  }
+
+  const providerDef = getProvider(provider);
+  return providerDef?.defaultBaseUrl || '';
+}
+
+/**
+ * Get available models for a provider
+ */
+export function getProviderModels(provider: ProviderType): string[] {
+  const globalConfig = loadGlobalConfig();
+  const providerConfig = globalConfig?.providers[provider];
+
+  if (providerConfig?.models && providerConfig.models.length > 0) {
+    return providerConfig.models;
+  }
+
+  const providerDef = getProvider(provider);
+  return providerDef?.defaultModels || [];
+}
+
+/**
+ * Validate a config object
+ */
+export function validateConfig(config: RuntimeConfig): { valid: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  // Validate provider
+  const providerDef = getProvider(config.provider);
+  if (!providerDef) {
+    errors.push(`无效的 provider: ${config.provider}`);
+  }
+
+  // Validate API key
+  if (providerDef) {
+    const keyValidation = validateApiKey(config.provider, config.apiKey);
+    if (!keyValidation.valid) {
+      errors.push(keyValidation.error || 'API Key 无效');
+    }
+  }
+
+  // Validate model
+  const availableModels = getProviderModels(config.provider);
+  if (availableModels.length > 0 && !availableModels.includes(config.model)) {
+    errors.push(
+      `模型 ${config.model} 在 provider ${config.provider} 中不可用。可用模型: ${availableModels.join(', ')}`
+    );
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  };
+}

package/src/config/storage.ts

@@ -0,0 +1,150 @@
+import os from 'os';
+import path from 'path';
+import fs from 'fs';
+
+export interface ProviderConfig {
+  apiKey: string;
+  baseUrl: string;
+  models: string[];
+}
+
+export interface GlobalConfig {
+  currentProvider: string;
+  providers: {
+    [key: string]: ProviderConfig;
+  };
+  defaults: {
+    provider: string;
+    model: string;
+    role: 'boss' | 'employee';
+    severity: 'mild' | 'medium' | 'extreme';
+  };
+  onboardingCompleted: boolean;
+}
+
+export interface ProjectConfig {
+  provider?: string;
+  model?: string;
+  role?: 'boss' | 'employee';
+  severity?: 'mild' | 'medium' | 'extreme';
+}
+
+/**
+ * Get the config directory path following XDG Base Directory Specification
+ */
+export function getConfigDir(): string {
+  const platform = process.platform;
+
+  if (platform === 'win32') {
+    // Windows: %APPDATA%\pua-cli
+    return path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), 'pua-cli');
+  } else {
+    // Linux/macOS: ~/.config/pua-cli
+    return path.join(os.homedir(), '.config', 'pua-cli');
+  }
+}
+
+/**
+ * Get the global config file path
+ */
+export function getGlobalConfigPath(): string {
+  return path.join(getConfigDir(), 'config.json');
+}
+
+/**
+ * Get the project config file path
+ */
+export function getProjectConfigPath(): string {
+  return path.join(process.cwd(), '.pua.json');
+}
+
+/**
+ * Ensure config directory exists
+ */
+export function ensureConfigDir(): void {
+  const configDir = getConfigDir();
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+}
+
+/**
+ * Load global config from file
+ */
+export function loadGlobalConfig(): GlobalConfig | null {
+  const configPath = getGlobalConfigPath();
+
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+
+  try {
+    const content = fs.readFileSync(configPath, 'utf-8');
+    return JSON.parse(content) as GlobalConfig;
+  } catch (error) {
+    throw new Error(`Failed to load config from ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+/**
+ * Save global config to file
+ */
+export function saveGlobalConfig(config: GlobalConfig): void {
+  ensureConfigDir();
+  const configPath = getGlobalConfigPath();
+
+  try {
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+  } catch (error) {
+    throw new Error(`Failed to save config to ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+/**
+ * Load project config from file
+ */
+export function loadProjectConfig(): ProjectConfig | null {
+  const configPath = getProjectConfigPath();
+
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+
+  try {
+    const content = fs.readFileSync(configPath, 'utf-8');
+    return JSON.parse(content) as ProjectConfig;
+  } catch (error) {
+    throw new Error(`Failed to load project config from ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+/**
+ * Check if global config exists
+ */
+export function hasGlobalConfig(): boolean {
+  return fs.existsSync(getGlobalConfigPath());
+}
+
+/**
+ * Check if onboarding has been completed
+ */
+export function isOnboardingCompleted(): boolean {
+  const config = loadGlobalConfig();
+  return config?.onboardingCompleted ?? false;
+}
+
+/**
+ * Get API key for a provider from config
+ */
+export function getProviderApiKey(provider: string): string | null {
+  const config = loadGlobalConfig();
+  return config?.providers[provider]?.apiKey ?? null;
+}
+
+/**
+ * Get current provider
+ */
+export function getCurrentProvider(): string | null {
+  const config = loadGlobalConfig();
+  return config?.currentProvider ?? null;
+}