@acip/cli 1.5.5 → 1.6.1

package/templates/advanced/src/components/assistant.ts.template

@@ -1,65 +1,345 @@
-import type { ModelInvocationModule, InvocationResponse, InvocationOptions } from '@acip/model-invocation';
+import * as readline from 'readline';
+import type { ModelInvocationModule } from '@acip/model-invocation';
 
-type AssistantOptions = {
+type Message = { role: 'system' | 'user' | 'assistant'; content: string };
+
+export interface AssistantModules {
+  modelInvocation: ModelInvocationModule;
   modelId: string;
-  provider?: string;
-  systemPrompt?: string;
-};
+  provider: string;
+  contextManager?: any;
+  contextId?: string | null;
+  blockchain?: any;
+  auditService?: any;
+  dataAccess?: any;
+  authManager?: any;
+}
 
-type Message = { role: 'system' | 'user' | 'assistant'; content: string };
+const SYSTEM_PROMPT = `You are ACIP Assistant, an AI powered by the Adaptive Contextual Intelligence Protocol (ACIP).
+ACIP is a distributed AI communication protocol providing semantic routing, resource-aware scheduling, QoS management, blockchain integration, and edge computing support.
+You have access to context management, data access, blockchain audit, and security modules.
+Help users understand and build with ACIP. Be concise and helpful.`;
+
+export function createAssistant(modules: AssistantModules) {
+  const {
+    modelInvocation,
+    modelId,
+    provider,
+    contextManager,
+    contextId,
+    blockchain,
+    auditService,
+    dataAccess,
+    authManager
+  } = modules;
 
-/**
- * 创建AI助手实例
- */
-export function createAssistant(
-  modelInvocation: ModelInvocationModule,
-  options: AssistantOptions
-) {
   const history: Message[] = [];
-  const provider = options.provider || 'openai';
-  const modelId = options.modelId;
-  const systemPrompt = options.systemPrompt || `
-You are ACIP Guide, an AI assistant specializing in the Adaptive Contextual Intelligence Protocol.
-Provide helpful, accurate, and concise information about ACIP's features, architecture, and usage.
-When asked about technical details, include code examples when appropriate.
-If you don't know something, admit it rather than making up information.
-`;
-
-  // 发送消息并返回响应
-  async function sendMessage(
-    content: string,
-    invokeOptions: Omit<InvocationOptions, 'model' | 'provider' | 'messages'> = {}
-  ): Promise<InvocationResponse> {
+  let requestCount = 0;
+  const requestTimeoutMs = Number(process.env.ACIP_REQUEST_TIMEOUT_MS || '180000');
+
+  const resolveModelsUrl = (rawBaseUrl?: string): string => {
+    const fallback = 'https://api.openai.com/v1';
+    const trimmed = (rawBaseUrl || fallback).replace(/\/$/, '');
+    if (trimmed.endsWith('/models')) {
+      return trimmed;
+    }
+    if (trimmed.endsWith('/v1')) {
+      return `${trimmed}/models`;
+    }
+    return `${trimmed}/v1/models`;
+  };
+
+  const listModels = async (): Promise<void> => {
+    const apiKey = process.env.OPENAI_API_KEY || process.env.ACIP_API_KEY;
+    const baseUrl = process.env.OPENAI_BASE_URL || process.env.ACIP_BASE_URL;
+
+    if (!apiKey) {
+      console.log('Missing API key. Set OPENAI_API_KEY (or ACIP_API_KEY) in .env file.');
+      console.log('');
+      return;
+    }
+
+    const modelsUrl = resolveModelsUrl(baseUrl);
+    try {
+      const response = await fetch(modelsUrl, {
+        method: 'GET',
+        headers: {
+          'Authorization': `Bearer ${apiKey}`
+        }
+      });
+
+      if (!response.ok) {
+        let errorMessage = `HTTP ${response.status}`;
+        try {
+          const error: any = await response.json();
+          errorMessage = error?.error?.message || error?.message || errorMessage;
+        } catch {
+          const text = await response.text();
+          if (text) {
+            errorMessage = text;
+          }
+        }
+        console.log(`Models list error: ${errorMessage}`);
+        console.log('');
+        return;
+      }
+
+      const data: any = await response.json();
+      const models = Array.isArray(data?.data)
+        ? data.data
+        : Array.isArray(data?.models)
+          ? data.models
+          : [];
+
+      if (models.length === 0) {
+        console.log('No models returned.');
+        console.log('');
+        return;
+      }
+
+      console.log('');
+      console.log(`--- Models (${models.length}) ---`);
+      for (const model of models) {
+        const id = model?.id || model?.name || model?.model || JSON.stringify(model);
+        console.log(`  - ${id}`);
+      }
+      console.log('---');
+      console.log('');
+    } catch (error: any) {
+      console.log(`Models list error: ${error.message}`);
+      console.log('');
+    }
+  };
+
+  const streamReply = (messages: Message[]): Promise<string> => new Promise((resolve, reject) => {
+    const stream = modelInvocation.invokeStream({
+      model: modelId,
+      provider,
+      timeout: requestTimeoutMs,
+      messages
+    });
+
+    let full = '';
+    process.stdout.write('\nAssistant> ');
+
+    stream.on('data', (chunk: any) => {
+
+      const content = chunk?.output?.content ?? chunk?.content;
+
+      if (typeof content === 'string') {
+
+        full += content;
+
+        process.stdout.write(content);
+
+      }
+
+    });
+
+    stream.on('end', () => {
+      process.stdout.write('\n\n');
+      resolve(full);
+    });
+
+    stream.on('error', (err: any) => {
+      const message = err?.error || err?.message || 'Unknown error';
+      process.stdout.write('\n');
+      reject(new Error(message));
+    });
+  });
+
+
+  async function sendMessage(content: string): Promise<string> {
     const messages: Message[] = [
-      { role: 'system', content: systemPrompt.trim() },
+      { role: 'system', content: SYSTEM_PROMPT },
       ...history,
       { role: 'user', content }
     ];
 
-    const response = await modelInvocation.invoke({
-      model: modelId,
-      provider,
-      messages,
-      ...invokeOptions
-    });
+    const responseContent = await streamReply(messages);
 
     history.push({ role: 'user', content });
-    history.push({ role: 'assistant', content: response.content });
+    history.push({ role: 'assistant', content: responseContent });
+    requestCount++;
+
+    // 自动保存到上下文管理
+    if (contextManager && contextId) {
+      try {
+        await contextManager.addToContext(contextId, {
+          type: 'text',
+          text: `User: ${content}\nAssistant: ${responseContent}`,
+          timestamp: Date.now()
+        });
+      } catch { /* 静默降级 */ }
+    }
+
+    // 自动审计到区块链
+    if (blockchain) {
+      try {
+        const tx = blockchain.createTransaction('user', 'ai-assistant', 1);
+        tx.type = 'CONTRIBUTION';
+        blockchain.addTransaction(tx);
+      } catch { /* 静默降级 */ }
+    }
 
-    return response;
+    return responseContent;
   }
 
-  function getHistory(): Message[] {
-    return [...history];
+  async function handleCommand(cmd: string): Promise<boolean> {
+    const parts = cmd.split(/\s+/);
+    const command = parts[0];
+
+    switch (command) {
+      case '/help':
+        console.log('\nCommands:');
+        console.log('  /help        - Show this help');
+        console.log('  /clear       - Clear conversation history');
+        console.log('  /history     - Show conversation history');
+        console.log('  /status      - Show module status');
+        console.log('  /models      - List available models');
+        console.log('  /audit       - Show blockchain audit trail');
+        console.log('  /data list   - List registered data sources');
+        console.log('  /exit        - Exit the application\n');
+        return true;
+
+      case '/clear':
+        history.length = 0;
+        requestCount = 0;
+        console.log('Conversation history cleared.\n');
+        return true;
+
+      case '/history':
+        if (history.length === 0) {
+          console.log('No conversation history yet.\n');
+        } else {
+          console.log(`\n--- Conversation History (${history.length} messages) ---`);
+          for (const msg of history) {
+            const prefix = msg.role === 'user' ? 'You' : 'Assistant';
+            const text = msg.content.length > 120
+              ? msg.content.substring(0, 120) + '...'
+              : msg.content;
+            console.log(`  [${prefix}] ${text}`);
+          }
+          console.log('---\n');
+        }
+        return true;
+
+      case '/status': {
+        console.log('\n--- Module Status ---');
+        console.log(`  Core:            active`);
+        console.log(`  Model Invocation: active (model: ${modelId})`);
+        console.log(`  Context Mgmt:    ${contextManager ? 'active' : 'unavailable'}`);
+        console.log(`  Data Access:     ${dataAccess ? 'active' : 'unavailable'}`);
+        console.log(`  Blockchain:      ${blockchain ? 'active' : 'unavailable'}`);
+        console.log(`  Security/Auth:   ${authManager ? 'active' : 'unavailable'}`);
+        console.log(`  Requests:        ${requestCount}`);
+        console.log(`  History:         ${history.length} messages`);
+        if (authManager) {
+          try {
+            const stats = authManager.getStats();
+            console.log(`  Users:           ${stats.userCount}`);
+            console.log(`  Sessions:        ${stats.sessionCount}`);
+          } catch { /* ignore */ }
+        }
+        console.log('---\n');
+        return true;
+      }
+
+      case '/models':
+        await listModels();
+        return true;
+
+      case '/audit':
+        if (!auditService) {
+          console.log('Blockchain audit is not available.\n');
+        } else {
+          try {
+            const trail = auditService.getAuditTrailForAddress('user');
+            if (trail.length === 0) {
+              console.log('No audit records yet.\n');
+            } else {
+              console.log(`\n--- Audit Trail (${trail.length} records) ---`);
+              for (const tx of trail.slice(-10)) {
+                const time = new Date(tx.timestamp).toLocaleTimeString();
+                console.log(`  [${time}] ${tx.from} -> ${tx.to} (${tx.type}, amount: ${tx.amount})`);
+              }
+              console.log('---\n');
+            }
+          } catch (err: any) {
+            console.log(`Audit error: ${err.message}\n`);
+          }
+        }
+        return true;
+
+      case '/data':
+        if (!dataAccess) {
+          console.log('Data Access module is not available.\n');
+        } else if (parts[1] === 'list') {
+          try {
+            const sources = dataAccess.listSources();
+            if (sources.length === 0) {
+              console.log('No data sources registered.\n');
+            } else {
+              console.log(`\n--- Data Sources (${sources.length}) ---`);
+              for (const src of sources) {
+                console.log(`  - ${src.name || src}`);
+              }
+              console.log('---\n');
+            }
+          } catch (err: any) {
+            console.log(`Data access error: ${err.message}\n`);
+          }
+        } else {
+          console.log('Usage: /data list\n');
+        }
+        return true;
+
+      case '/exit':
+      case '/quit':
+        console.log('Goodbye!');
+        process.exit(0);
+
+      default:
+        return false;
+    }
   }
 
-  function clearHistory(): void {
-    history.length = 0;
+  function startREPL(): void {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    console.log('\n=== ACIP Advanced Assistant ===');
+    console.log('All modules integrated. Type /help for commands.\n');
+
+    const prompt = (): void => {
+      rl.question('You> ', async (input) => {
+        const trimmed = input.trim();
+        if (!trimmed) { prompt(); return; }
+
+        if (trimmed.startsWith('/')) {
+          const handled = await handleCommand(trimmed);
+          if (handled) { prompt(); return; }
+        }
+
+        try {
+          await sendMessage(trimmed);
+        } catch (error: any) {
+          console.error(`\nError: ${error.message}\n`);
+        }
+
+        prompt();
+      });
+    };
+
+    prompt();
   }
 
   return {
+    startREPL,
     sendMessage,
-    getHistory,
-    clearHistory
+    getHistory: (): Message[] => [...history],
+    clearHistory: (): void => { history.length = 0; }
   };
 }

package/templates/advanced/src/index.js.template

@@ -1,4 +1,5 @@
 import 'dotenv/config';
+import { createCore } from '@acip/core';
 import { ModelInvocationModule } from '@acip/model-invocation';
 import { createAssistant } from './components/assistant.js';
 
@@ -6,62 +7,144 @@ async function main() {
   const apiKey = process.env.OPENAI_API_KEY || process.env.ACIP_API_KEY;
   const baseUrl = process.env.OPENAI_BASE_URL || process.env.ACIP_BASE_URL;
   const modelId = process.env.DEFAULT_MODEL_ID || 'gpt-5.2';
+  const requestTimeoutMs = Number(process.env.ACIP_REQUEST_TIMEOUT_MS || '180000');
 
   if (!apiKey) {
-    throw new Error('Missing API key. Set OPENAI_API_KEY (or ACIP_API_KEY).');
+    console.error('Missing API key. Set OPENAI_API_KEY (or ACIP_API_KEY) in .env file.');
+    process.exit(1);
   }
 
+  // ── 1. ACIP Core ──
+  const core = createCore();
+  console.log(`[core] initialized (instance: ${core.instanceId})`);
+
+  // ── 2. Model Invocation ──
   const provider = {
     name: 'openai',
     apiKey,
     baseUrl,
     enabled: true,
-    models: [
-      {
-        id: modelId,
-        name: modelId,
-        provider: 'openai',
-        capabilities: ['chat'],
-        parameters: {}
-      }
-    ]
+    models: [{
+      id: modelId,
+      name: modelId,
+      provider: 'openai',
+      capabilities: ['chat'],
+      parameters: {}
+    }]
   };
 
-  const config = {
+  const miConfig = {
     providers: [provider],
     caching: { enabled: true, ttl: 600, maxSize: 100, strategy: 'lru' },
     observability: { enabled: true, metricsEnabled: true, tracingEnabled: false, exportInterval: 60000 },
-    streaming: { enabled: false, chunkSize: 1, timeout: 60000 }
+    streaming: { enabled: true, chunkSize: 1, timeout: requestTimeoutMs }
   };
 
-  const modelInvocation = new ModelInvocationModule(config);
+  const modelInvocation = new ModelInvocationModule(miConfig);
 
   await new Promise((resolve, reject) => {
     modelInvocation.once('ready', () => resolve());
     modelInvocation.once('error', (error) => reject(error));
   });
 
-  modelInvocation.on('requestStarted', (data) => {
-    console.log(`Model invocation started: ${data.requestId}`);
-  });
+  console.log('[model-invocation] ready');
 
-  modelInvocation.on('requestCompleted', (data) => {
-    console.log(`Model invocation completed in ${data.duration}ms`);
-  });
+  // ── 3. Context Management (降级运行) ──
+  let contextManager = null;
+  let contextId = null;
+  try {
+    const { ContextManager } = await import('@acip/context-management');
+    contextManager = new ContextManager(
+      core.instanceId,
+      core.stateManager,
+      core.telemetryService,
+      core.eventManager
+    );
+    await contextManager.initialize();
+    await contextManager.createContext('main-conversation');
+    contextId = 'main-conversation';
+    console.log('[context-management] ready');
+  } catch (err) {
+    console.warn(`[context-management] skipped: ${err.message}`);
+  }
 
-  const assistant = createAssistant(modelInvocation, {
-    modelId,
-    provider: 'openai'
-  });
+  // ── 4. Data Access (降级运行) ──
+  let dataAccess = null;
+  try {
+    const { DataAccessModule, InMemoryAdapter } = await import('@acip/data-access');
+    dataAccess = new DataAccessModule();
+    const adapter = new InMemoryAdapter();
+    await dataAccess.registerSource('notes', { adapter });
+    console.log('[data-access] ready');
+  } catch (err) {
+    console.warn(`[data-access] skipped: ${err.message}`);
+  }
 
-  const response = await assistant.sendMessage(
-    'Hello! I want to learn about adaptive context management in AI systems.'
-  );
+  // ── 5. Blockchain + Audit (降级运行) ──
+  let blockchain = null;
+  let auditService = null;
+  try {
+    const { Blockchain, AuditService } = await import('@acip/blockchain');
+    blockchain = new Blockchain();
+    auditService = new AuditService(blockchain);
+    console.log('[blockchain] ready');
+  } catch (err) {
+    console.warn(`[blockchain] skipped: ${err.message}`);
+  }
+
+  // ── 6. Security & Authentication (降级运行) ──
+  let authManager = null;
+  try {
+    const { AuthManager } = await import('@acip/security-authentication');
+    authManager = new AuthManager({
+      passwordPolicy: {
+        minLength: 4,
+        requireNumbers: false,
+        requireLowercase: false,
+        requireUppercase: false,
+        requireSpecial: false,
+        maxRepeatingChars: 0,
+        preventCommonPasswords: false
+      }
+    });
+    await authManager.initialize({
+      jwtSecret: process.env.JWT_SECRET || 'acip-demo-secret'
+    });
+    await authManager.start();
+
+    const adminPassword = process.env.ADMIN_PASSWORD || 'admin';
+    try {
+      await authManager.registerUser('admin', {
+        password: adminPassword,
+        roles: ['admin']
+      });
+      const auth = await authManager.authenticate('admin', adminPassword);
+      if (auth.authenticated) {
+        console.log('[security] ready — admin authenticated');
+      }
+    } catch {
+      // 用户可能已存在
+    }
+    console.log('[security-authentication] ready');
+  } catch (err) {
+    console.warn(`[security-authentication] skipped: ${err.message}`);
+  }
 
-  console.log('Assistant Response:', response.content);
+  // ── 启动交互式助手 ──
+  const modules = {
+    modelInvocation,
+    modelId,
+    provider: 'openai',
+    contextManager,
+    contextId,
+    blockchain,
+    auditService,
+    dataAccess,
+    authManager
+  };
 
-  const history = assistant.getHistory();
-  console.log(`Conversation has ${history.length} messages`);
+  const assistant = createAssistant(modules);
+  assistant.startREPL();
 }
 
 main().catch(console.error);