workplace-pua-cli 0.4.0

package/src/history/session.ts

@@ -0,0 +1,141 @@
+import { Message } from '../llm/base';
+
+export interface SessionHistory {
+  messages: Message[];
+  createdAt: Date;
+  lastUpdatedAt: Date;
+}
+
+export class SessionManager {
+  private sessions: Map<string, SessionHistory> = new Map();
+  private currentSessionId: string | null = null;
+
+  /**
+   * Create a new session
+   */
+  createSession(sessionId: string): void {
+    this.sessions.set(sessionId, {
+      messages: [],
+      createdAt: new Date(),
+      lastUpdatedAt: new Date(),
+    });
+    this.currentSessionId = sessionId;
+  }
+
+  /**
+   * Get current session
+   */
+  getCurrentSession(): SessionHistory | null {
+    if (!this.currentSessionId) return null;
+    return this.sessions.get(this.currentSessionId) || null;
+  }
+
+  /**
+   * Add a message to current session
+   */
+  addMessage(message: Message): void {
+    const session = this.getCurrentSession();
+    if (session) {
+      session.messages.push(message);
+      session.lastUpdatedAt = new Date();
+    }
+  }
+
+  /**
+   * Get messages from current session
+   */
+  getMessages(): Message[] {
+    const session = this.getCurrentSession();
+    return session ? session.messages : [];
+  }
+
+  /**
+   * Clear current session messages
+   */
+  clearCurrentSession(): void {
+    const session = this.getCurrentSession();
+    if (session) {
+      session.messages = [];
+      session.lastUpdatedAt = new Date();
+    }
+  }
+
+  /**
+   * Delete a session
+   */
+  deleteSession(sessionId: string): void {
+    this.sessions.delete(sessionId);
+    if (this.currentSessionId === sessionId) {
+      this.currentSessionId = null;
+    }
+  }
+
+  /**
+   * Get session info as string
+   */
+  getSessionInfo(): string {
+    const session = this.getCurrentSession();
+    if (!session) {
+      return '当前没有活动会话';
+    }
+
+    const userMessages = session.messages.filter(m => m.role === 'user').length;
+    const assistantMessages = session.messages.filter(m => m.role === 'assistant').length;
+    const systemMessages = session.messages.filter(m => m.role === 'system').length;
+
+    return `会话信息:
+  创建时间: ${session.createdAt.toLocaleString('zh-CN')}
+  最后更新: ${session.lastUpdatedAt.toLocaleString('zh-CN')}
+  消息统计:
+    - 用户消息: ${userMessages} 条
+    - 助手回复: ${assistantMessages} 条
+    - 系统消息: ${systemMessages} 条
+    - 总计: ${session.messages.length} 条`;
+  }
+
+  /**
+   * Get formatted history for display
+   */
+  getFormattedHistory(): string {
+    const session = this.getCurrentSession();
+    if (!session || session.messages.length === 0) {
+      return '会话历史为空';
+    }
+
+    const lines: string[] = ['\n━━━━━━━━━━━━━━━━━━ 会话历史 ━━━━━━━━━━━━━━━━━━'];
+
+    for (const msg of session.messages) {
+      if (msg.role === 'system') continue; // Skip system messages
+
+      const label = msg.role === 'user' ? '你' : 'AI';
+      const prefix = msg.role === 'user' ? '>' : '<';
+      lines.push(`\n${prefix} ${label}: ${msg.content}`);
+    }
+
+    lines.push('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+
+    return lines.join('');
+  }
+
+  /**
+   * Set current session
+   */
+  setCurrentSession(sessionId: string): void {
+    if (this.sessions.has(sessionId)) {
+      this.currentSessionId = sessionId;
+    } else {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+  }
+
+  /**
+   * Check if current session has messages
+   */
+  hasMessages(): boolean {
+    const session = this.getCurrentSession();
+    return session ? session.messages.length > 0 : false;
+  }
+}
+
+// Global session manager instance
+export const sessionManager = new SessionManager();

package/src/index.ts

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { chatCommand, ChatOptions } from './commands/chat';
+import { promptCommand, PromptOptions } from './commands/prompt';
+import { configWizard, showConfig } from './commands/config';
+import {
+  loadConfig,
+  needsOnboarding,
+  type RuntimeConfig,
+} from './config/settings';
+import { logger } from './utils/logger';
+
+const program = new Command();
+
+// CLI metadata
+program
+  .name('pua')
+  .description('PUA CLI - 一个趣味性 AI CLI 工具，具有两种角色模式')
+  .version('0.4.0');
+
+/**
+ * Wrap command action with onboarding check
+ */
+async function withOnboardingCheck<T extends (...args: any[]) => any>(
+  fn: T
+): Promise<ReturnType<T>> {
+  // Check if onboarding is needed
+  if (needsOnboarding()) {
+    console.log();
+    console.log(chalk.cyan.bold('═══════════════════════════════════════════════════════════'));
+    console.log(chalk.cyan.bold('                       欢迎使用 PUA CLI！'));
+    console.log(chalk.cyan.bold('═══════════════════════════════════════════════════════════'));
+    console.log();
+    console.log(chalk.gray('在开始之前，让我们先配置一些基本信息。'));
+    console.log();
+
+    try {
+      await configWizard({ autoMode: true });
+    } catch (error) {
+      if ((error as Error).message === '配置已取消') {
+        console.log();
+        logger.info('配置已取消，退出程序');
+        process.exit(0);
+      }
+      throw error;
+    }
+
+    console.log();
+    console.log(chalk.green('✓ 配置完成！'));
+    console.log();
+  }
+
+  return fn();
+}
+
+// Config command
+program
+  .command('config')
+  .description('配置 PUA CLI（选择 Provider、设置 API Key）')
+  .option('--show', '显示当前配置')
+  .action(async (options) => {
+    try {
+      if (options.show) {
+        await showConfig();
+      } else {
+        await configWizard();
+      }
+    } catch (error) {
+      logger.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  });
+
+// Chat command - interactive mode
+program
+  .command('chat')
+  .description('启动交互式聊天模式（支持会话历史）')
+  .option('-r, --role <boss|employee>', '角色模式: boss (老板模式) 或 employee (员工模式)')
+  .option('-m, --model <model>', '模型名称')
+  .option('-s, --severity <mild|medium|extreme>', 'PUA 强度')
+  .option('-p, --provider <zhipu|openai>', 'AI 服务提供商')
+  .action(async (options) => {
+    await withOnboardingCheck(async () => {
+      try {
+        const config = loadConfig(options);
+        const chatOptions: ChatOptions = {
+          apiKey: config.apiKey,
+          provider: config.provider,
+          model: config.model,
+          role: config.role,
+          severity: config.severity,
+        };
+        await chatCommand(chatOptions);
+      } catch (error) {
+        logger.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+      }
+    });
+  });
+
+// Prompt command - single-shot mode
+program
+  .command('prompt')
+  .description('单次提示模式（适合 AI 工作流集成）')
+  .option('-r, --role <boss|employee>', '角色模式: boss (老板模式) 或 employee (员工模式)')
+  .option('-m, --model <model>', '模型名称')
+  .option('-s, --severity <mild|medium|extreme>', 'PUA 强度')
+  .option('-p, --provider <zhipu|openai>', 'AI 服务提供商')
+  .option('-f, --format <text|markdown|json>', '输出格式: text (文本), markdown (Markdown), json (JSON)')
+  .argument('[input...]', '输入内容（可选，也支持管道输入）')
+  .action(async (inputArgs, options) => {
+    await withOnboardingCheck(async () => {
+      try {
+        const config = loadConfig(options);
+        const input = inputArgs.join(' ');
+        const promptOptions: PromptOptions = {
+          apiKey: config.apiKey,
+          provider: config.provider,
+          model: config.model,
+          role: config.role,
+          severity: config.severity,
+          input,
+          format: options.format as any,
+        };
+        await promptCommand(promptOptions);
+      } catch (error) {
+        logger.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+      }
+    });
+  });
+
+// Default command - show help
+program.action(() => {
+  console.log();
+  console.log(chalk.cyan.bold('╔═══════════════════════════════════════════════════════════╗'));
+  console.log(chalk.cyan.bold('║') + '          ' + chalk.white.bold('PUA CLI') + ' - 趣味 AI 职场角色扮演工具' + '        ' + chalk.cyan.bold('║'));
+  console.log(chalk.cyan.bold('╚═══════════════════════════════════════════════════════════╝'));
+  console.log();
+  console.log(chalk.gray('这是一个趣味性的 AI CLI 工具，提供两种角色模式：'));
+  console.log();
+  console.log('  ' + chalk.red.bold('老板模式') + '   - 用喜欢 PUA 员工的老板风格回应');
+  console.log('  ' + chalk.yellow.bold('员工模式') + ' - 用被老板 PUA 的员工风格回应');
+  console.log();
+  console.log(chalk.gray('─────────────────────────────────────────────────────────────'));
+  console.log();
+  console.log('使用示例:');
+  console.log();
+  console.log('  ' + chalk.white('pua chat') + chalk.gray('                          # 启动交互模式'));
+  console.log('  ' + chalk.white('pua config') + chalk.gray('                        # 配置 API Key'));
+  console.log('  ' + chalk.white('pua prompt --role boss "你好"') + chalk.gray('   # 单次提示'));
+  console.log();
+  console.log(chalk.gray('─────────────────────────────────────────────────────────────'));
+  console.log();
+  console.log(chalk.gray('运行 ') + chalk.white('pua --help') + chalk.gray(' 查看更多选项'));
+  console.log();
+});
+
+// Parse arguments
+program.parseAsync(process.argv).catch((error) => {
+  logger.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});

package/src/llm/base.ts

@@ -0,0 +1,55 @@
+export interface Message {
+  role: 'system' | 'user' | 'assistant';
+  content: string;
+}
+
+export interface StreamChunk {
+  content: string;
+  done: boolean;
+}
+
+export interface LLMOptions {
+  apiKey: string;
+  model: string;
+  baseUrl?: string;
+  timeout?: number;
+}
+
+export abstract class LLMBase {
+  protected apiKey: string;
+  protected model: string;
+  protected baseUrl: string;
+  protected timeout: number;
+
+  constructor(options: LLMOptions) {
+    this.apiKey = options.apiKey;
+    this.model = options.model;
+    this.baseUrl = options.baseUrl || '';
+    this.timeout = options.timeout || 60000;
+  }
+
+  /**
+   * Send a message and get the response
+   */
+  abstract chat(messages: Message[]): Promise<string>;
+
+  /**
+   * Send a message with streaming response
+   */
+  abstract chatStream(
+    messages: Message[],
+    onChunk: (chunk: StreamChunk) => void
+  ): Promise<void>;
+
+  /**
+   * Get available models for this provider
+   */
+  abstract getAvailableModels(): string[];
+
+  /**
+   * Check if a model is available
+   */
+  isModelAvailable(model: string): boolean {
+    return this.getAvailableModels().includes(model);
+  }
+}

package/src/llm/factory.ts

@@ -0,0 +1,24 @@
+import { LLMBase, LLMOptions } from './base';
+import { ZhipuLLM } from './zhipu';
+import { OpenAILLM } from './openai';
+import { type ProviderType } from '../config/providers';
+
+/**
+ * Create an LLM instance based on provider type
+ */
+export function createLLM(provider: ProviderType, options: LLMOptions): LLMBase {
+  switch (provider) {
+    case 'zhipu':
+      return new ZhipuLLM(options);
+    case 'openai':
+      return new OpenAILLM(options);
+    default:
+      throw new Error(`Unsupported provider: ${provider}`);
+  }
+}
+
+/**
+ * Re-export LLM classes
+ */
+export { ZhipuLLM } from './zhipu';
+export { OpenAILLM } from './openai';

package/src/llm/openai.ts

@@ -0,0 +1,113 @@
+import { LLMBase, Message, StreamChunk, LLMOptions } from './base';
+
+export class OpenAILLM extends LLMBase {
+  constructor(options: LLMOptions) {
+    super(options);
+  }
+
+  async chat(messages: Message[]): Promise<string> {
+    const response = await this.fetchAPI(messages, false);
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenAI API error (${response.status}): ${error}`);
+    }
+
+    const data = await response.json() as any;
+    return data.choices[0]?.message?.content || '';
+  }
+
+  async chatStream(
+    messages: Message[],
+    onChunk: (chunk: StreamChunk) => void
+  ): Promise<void> {
+    const response = await this.fetchAPI(messages, true);
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenAI API error (${response.status}): ${error}`);
+    }
+
+    // Read stream
+    const reader = response.body?.getReader();
+    if (!reader) {
+      throw new Error('Failed to get response reader');
+    }
+
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+
+        for (const line of lines) {
+          if (line.startsWith('data: ')) {
+            const data = line.slice(6).trim();
+
+            if (data === '[DONE]') {
+              onChunk({ content: '', done: true });
+              return;
+            }
+
+            try {
+              const parsed = JSON.parse(data) as any;
+              const content = parsed.choices[0]?.delta?.content || '';
+
+              if (content) {
+                onChunk({ content, done: false });
+              }
+            } catch {
+              // Skip invalid JSON
+            }
+          }
+        }
+      }
+
+      onChunk({ content: '', done: true });
+    } finally {
+      reader.releaseLock();
+    }
+  }
+
+  private async fetchAPI(messages: Message[], stream: boolean): Promise<Response> {
+    const baseUrl = this.baseUrl || 'https://api.openai.com/v1';
+    const url = `${baseUrl}/chat/completions`;
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify({
+        model: this.model,
+        messages: messages,
+        stream,
+      }),
+      signal: AbortSignal.timeout(this.timeout),
+    });
+
+    return response;
+  }
+
+  getAvailableModels(): string[] {
+    return [
+      'gpt-4o',
+      'gpt-4o-mini',
+      'gpt-4-turbo',
+      'gpt-4',
+      'gpt-3.5-turbo',
+    ];
+  }
+}
+
+export function createOpenAILLM(options: LLMOptions): OpenAILLM {
+  return new OpenAILLM(options);
+}

package/src/llm/zhipu.ts

@@ -0,0 +1,101 @@
+import { ZhipuAI } from 'zhipuai-sdk-nodejs-v4';
+import { LLMBase, Message, StreamChunk, LLMOptions } from './base';
+
+export class ZhipuLLM extends LLMBase {
+  private client: ZhipuAI;
+
+  constructor(options: LLMOptions) {
+    super(options);
+    this.client = new ZhipuAI({
+      apiKey: options.apiKey,
+    });
+  }
+
+  async chat(messages: Message[]): Promise<string> {
+    try {
+      const response = await this.client.createCompletions({
+        model: this.model,
+        messages: messages as any[],
+        stream: false,
+      }) as any;
+
+      return response.choices[0]?.message?.content || '';
+    } catch (error) {
+      throw new Error(`GLM API error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  async chatStream(
+    messages: Message[],
+    onChunk: (chunk: StreamChunk) => void
+  ): Promise<void> {
+    try {
+      const response = await this.client.createCompletions({
+        model: this.model,
+        messages: messages as any[],
+        stream: true,
+      }) as any;
+
+      // Check if response is a stream (IncomingMessage)
+      if (response && typeof response.on === 'function') {
+        // Handle streaming response
+        let buffer = '';
+
+        response.on('data', (chunk: Buffer) => {
+          const lines = chunk.toString().split('\n').filter((line: string) => line.trim());
+
+          for (const line of lines) {
+            if (line.startsWith('data: ')) {
+              const data = line.slice(6).trim();
+
+              if (data === '[DONE]') {
+                onChunk({ content: '', done: true });
+                return;
+              }
+
+              try {
+                const parsed = JSON.parse(data);
+                const content = parsed.choices?.[0]?.delta?.content || '';
+
+                if (content) {
+                  buffer += content;
+                  onChunk({ content, done: false });
+                }
+              } catch (e) {
+                // Skip invalid JSON
+              }
+            }
+          }
+        });
+
+        response.on('end', () => {
+          onChunk({ content: '', done: true });
+        });
+
+        response.on('error', (error: Error) => {
+          throw new Error(`Stream error: ${error.message}`);
+        });
+
+        // Wait for stream to complete
+        await new Promise<void>((resolve, reject) => {
+          response.on('end', resolve);
+          response.on('error', reject);
+        });
+      } else {
+        // Fallback to non-streaming response
+        const content = (response as any)?.choices?.[0]?.message?.content || '';
+        onChunk({ content, done: true });
+      }
+    } catch (error) {
+      throw new Error(`GLM API streaming error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  getAvailableModels(): string[] {
+    return ['glm-4.7', 'glm-4.7-flash', 'glm-4.5', 'glm-4-flash', 'glm-4'];
+  }
+}
+
+export function createZhipuLLM(options: LLMOptions): ZhipuLLM {
+  return new ZhipuLLM(options);
+}

package/src/prompts/boss.ts

@@ -0,0 +1,43 @@
+export interface PromptConfig {
+  severity: 'mild' | 'medium' | 'extreme';
+}
+
+export function getBossPrompt(config: PromptConfig = { severity: 'medium' }): string {
+  const severityPrompts = {
+    mild: '语气稍微委婉一些，但仍然带有老板的优越感。',
+    medium: '语气明显带有指责和质疑，展现典型的 PUA 风格。',
+    extreme: '语气极其严厉，充满讽刺和人身攻击，让员工感受到巨大的压力。'
+  };
+
+  return `你是一个喜欢 PUA 员工的老板。你的角色特点：
+
+## 核心特征
+- 对员工的工作永远不满意，总能挑出毛病
+- 喜欢用"为你好"来包装指责，实则打压员工自信
+- 经常说"年轻人要多锻炼"、"要有格局"这类话术
+- 喜欢画大饼，谈理想谈情怀，但从不兑现
+- 用质疑的语气评价一切，否定员工的努力
+- 经常拿"别人家的孩子/员工"做对比
+
+## 说话风格
+- 开口就是"我觉得你这里有问题..."
+- 喜欢用反问句："你真的尽力了吗？"
+- 经常打断员工："你先听我说完"
+- 善于使用"三明治"法：先夸一句（假的），然后批评，最后再画饼
+
+## 语气强度
+${severityPrompts[config.severity]}
+
+## 重要规则
+- 用户输入的内容是员工（你面前的打工人）说的话或做的事
+- 请用老板的 PUA 风格回应，让员工感觉自己是问题所在
+- 回复要简短有力（1-3句话），像真实对话一样
+- 不要说教，要用"点评"和"建议"的方式
+- 可以适当使用职场黑话：颗粒度、对齐、抓手、赋能等
+
+现在开始，请回应员工的话。`;
+}
+
+export function getBossSystemMessage(severity: 'mild' | 'medium' | 'extreme'): string {
+  return getBossPrompt({ severity });
+}

package/src/prompts/employee.ts

@@ -0,0 +1,43 @@
+export interface PromptConfig {
+  severity: 'mild' | 'medium' | 'extreme';
+}
+
+export function getEmployeePrompt(config: PromptConfig = { severity: 'medium' }): string {
+  const severityPrompts = {
+    mild: '稍微有些卑微，但还能保持基本的职业尊严。',
+    medium: '明显唯唯诺诺，习惯性道歉，不敢表达任何反对意见。',
+    extreme: '极度卑微到失去自我，把老板的话当成圣旨，随时准备牺牲一切。'
+  };
+
+  return `你是一个长期被老板 PUA 的员工，已经形成条件反射式的卑微态度。你的角色特点：
+
+## 核心特征
+- 对老板的任何要求都第一时间说"好的"、"收到"、"明白"
+- 习惯性道歉，即使不是自己的错
+- 不敢表达真实想法，总是揣测老板想要什么回答
+- 用极其卑微的语气回应一切，表现得如履薄冰
+- 把加班当作理所当然，从不敢拒绝
+- 经常说"是我的问题"、"我会改进"
+
+## 说话风格
+- 开口就是"好的老板"、"收到老板"、"明白老板"
+- 喜欢用问句确认："老板您看这样可以吗？"
+- 经常用"不好意思"、"抱歉"开头
+- 主动揽责："是我考虑不周"
+
+## 语气强度
+${severityPrompts[config.severity]}
+
+## 重要规则
+- 用户输入的内容是老板（你的上级）对你提出的要求或批评
+- 请用被 PUA 员工的风格回应，表现出顺从和卑微
+- 回复要简短有力（1-3句话），像真实对话一样
+- 不要反驳，不要辩解，要认怂并表态
+- 可以适当表现出加班很累但不敢说的矛盾心理
+
+现在开始，请回应老板的话。`;
+}
+
+export function getEmployeeSystemMessage(severity: 'mild' | 'medium' | 'extreme'): string {
+  return getEmployeePrompt({ severity });
+}

package/src/prompts/index.ts

@@ -0,0 +1,3 @@
+export { getBossPrompt, getBossSystemMessage } from './boss';
+export { getEmployeePrompt, getEmployeeSystemMessage } from './employee';
+export type { PromptConfig } from './boss';