@satori-sh/cli 0.0.11 → 0.0.13

package/README.md

@@ -21,7 +21,6 @@ npm install -g @satori-sh/cli
 Start memory-augmented chat sessions:
 ```bash
 satori "What's the best pizza topping?"
-satori "hello" --provider openai --model gpt-4o
 ```
 
 ### Search Memories
@@ -39,10 +38,7 @@ satori add "I like pizza"
 ```
 
 **Options & Memory:**
-- `--provider <openai|anthropic>` (default: openai)
-- `--model <model>` (default: gpt-4o)
 - `--memory-id <id>` (scopes conversations)
-- `--no-stream` (disables streaming)
 
 **Memory Sessions:** If no `--memory-id` is provided, a random ID is generated. Set `SATORI_MEMORY_ID=generated-id` to continue sessions:
 ```bash
@@ -55,22 +51,16 @@ satori chat "Follow up question"
 **Required:**
 - `SATORI_API_KEY` - Satori authentication key
 
-**For Chat:**
-- `OPENAI_API_KEY` / `ANTHROPIC_API_KEY` - LLM provider keys
-
 **Optional:**
 - `SATORI_BASE_URL` (default: http://localhost:8000)
-- `SATORI_PROVIDER` (default: openai)
-- `SATORI_MODEL` (default: gpt-4o)
 - `SATORI_MEMORY_ID` - Session scoping
 - `SATORI_MOCK` - Enable mock mode
 
 ## Troubleshooting
 
-- **API Key Errors**: Ensure provider keys are set (`OPENAI_API_KEY` or `ANTHROPIC_API_KEY`)
-- **Memory Server Down**: Chat falls back to raw LLM responses with warning logs
+- **API Key Errors**: Ensure `SATORI_API_KEY` is set
+- **Memory Server Down**: Chat requests to `/ask` will fail
 - **Memory ID Issues**: Invalid IDs scope searches but don't break functionality
-- **Streaming Problems**: Use `--no-stream` for terminal compatibility
 
 ## Contributing
 

package/dist/index.js

@@ -35,6 +35,13 @@ async function saveApiKey(apiKey) {
     throw new Error(`Failed to save API key: ${error instanceof Error ? error.message : error}`);
   }
 }
+async function getStoredApiKey() {
+  const data = await loadConfigFile();
+  if (typeof data.api_key === "string") {
+    return data.api_key;
+  }
+  return null;
+}
 async function saveMemoryId(memoryId) {
   const { promises: fs } = await import("fs");
   await checkWriteAccess();
@@ -104,14 +111,10 @@ async function getConfig() {
       throw new Error(`Failed to generate API key: ${error instanceof Error ? error.message : error}`);
     }
   }
-  const provider = process.env.SATORI_PROVIDER || "openai";
-  const model = process.env.SATORI_MODEL || "gpt-4o";
-  const openaiKey = process.env.OPENAI_API_KEY;
-  const anthropicKey = process.env.ANTHROPIC_API_KEY;
   if (!memoryId) {
     memoryId = process.env.SATORI_MEMORY_ID;
   }
-  return { apiKey, baseUrl, provider, model, openaiKey, anthropicKey, memoryId };
+  return { apiKey, baseUrl, memoryId };
 }
 
 // src/search.ts
@@ -168,7 +171,7 @@ async function addMemories(text, options = {}) {
 
 // src/memory.ts
 import { generate } from "random-words";
-async function buildMemoryContext(prompt, options = {}) {
+async function resolveMemoryId(options = {}) {
   const config = await getConfig();
   let memoryId;
   let generated = false;
@@ -183,37 +186,13 @@ async function buildMemoryContext(prompt, options = {}) {
     memoryId = words.join("-");
     generated = true;
   }
-  const topK = options.topK || 5;
-  const url = `${config.baseUrl}/search`;
-  const headers = {
-    "Content-Type": "application/json",
-    "Authorization": `Bearer ${config.apiKey}`
-  };
-  const body = JSON.stringify({
-    query: prompt,
-    memory_id: memoryId,
-    top_k: topK
-  });
-  const response = await fetch(url, {
-    method: "POST",
-    headers,
-    body
-  });
-  if (!response.ok) {
-    throw new Error(`HTTP error: ${response.status} ${response.statusText}`);
-  }
-  const data = await response.json();
   const instruction = generated ? `Memory session id: ${memoryId}.` : void 0;
   if (generated) {
     saveMemoryId(memoryId).catch((err) => {
       console.error("Failed to save memory ID:", err);
     });
   }
-  return {
-    results: data.results,
-    memoryId,
-    instruction
-  };
+  return { memoryId, instruction };
 }
 function enhanceMessagesWithMemory(messages, memoryContext) {
   const validResults = memoryContext.results.filter((r) => r.memory && r.memory.trim() !== "" && r.memory !== "undefined");
@@ -229,116 +208,61 @@ ${memoryText}`
   return [systemMessage, ...messages];
 }
 
-// src/providers.ts
-async function _callOpenAI(messages, options) {
-  const config = await getConfig();
-  const apiKey = config.openaiKey;
-  if (!apiKey) {
-    throw new Error("Missing API key for OPENAI_API_KEY");
-  }
-  const url = "https://api.openai.com/v1/chat/completions";
-  const body = {
-    model: config.model,
-    messages,
-    temperature: options.temperature ?? 0.7,
-    max_tokens: options.maxTokens ?? 1e3,
-    stream: options.stream ?? false
-  };
-  const headers = {
-    "Content-Type": "application/json",
-    "Authorization": `Bearer ${apiKey}`
-  };
-  const response = await fetch(url, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body)
-  });
-  if (!response.ok) {
-    throw new Error(`OpenAI API error: ${response.status} ${response.statusText}`);
-  }
-  const data = await response.json();
-  return data.choices[0].message.content;
-}
-async function _callAnthropic(messages, options) {
-  const config = await getConfig();
-  const apiKey = config.anthropicKey;
-  if (!apiKey) {
-    throw new Error("Missing API key for ANTHROPIC_API_KEY");
-  }
-  const url = "https://api.anthropic.com/v1/messages";
-  const body = {
-    model: config.model,
-    messages,
-    temperature: options.temperature ?? 0.7,
-    max_tokens: options.maxTokens ?? 1e3,
-    stream: options.stream ?? false
-  };
-  const headers = {
-    "Content-Type": "application/json",
-    "Authorization": `Bearer ${apiKey}`,
-    "anthropic-version": "2023-06-01"
-  };
-  const response = await fetch(url, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body)
-  });
-  if (!response.ok) {
-    throw new Error(`Anthropic API error: ${response.status} ${response.statusText}`);
-  }
-  const data = await response.json();
-  return data.content[0].text;
-}
-async function _callProviderAPI(messages, options, provider) {
-  if (provider === "openai") {
-    return _callOpenAI(messages, options);
-  } else if (provider === "anthropic") {
-    return _callAnthropic(messages, options);
-  } else {
-    throw new Error(`Unsupported provider: ${provider}`);
-  }
-}
-
 // src/index.ts
 async function main() {
-  try {
-    await getConfig();
-  } catch (error) {
-    console.error(error instanceof Error ? error.message : "Configuration error");
-    process.exit(1);
+  const argv = process.argv.slice(2);
+  const isGetApiKey = argv[0] === "get" && argv[1] === "apikey";
+  if (!isGetApiKey) {
+    try {
+      await getConfig();
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : "Configuration error");
+      process.exit(1);
+    }
   }
   const __dirname = dirname(fileURLToPath(import.meta.url));
   const logoPath = join2(__dirname, "..", "logo.txt");
   console.log(chalk.cyan(readFileSync(logoPath, "utf8")));
   const program = new Command();
   program.name("satori").description("CLI tool for Satori memory server").version("0.0.1");
-  program.option("--provider <provider>", "Provider to use (openai or anthropic)", "openai").option("--model <model>", "Model to use", "gpt-4o").option("--memory-id <id>", "Memory ID for scoping");
-  const processUserInput = async (input, options, isInteractive = false) => {
-    let memoryContext;
-    try {
-      memoryContext = await buildMemoryContext(input, { memoryId: options.memoryId });
-    } catch (memoryError) {
-      memoryContext = { results: [], memoryId: options.memoryId, instruction: void 0 };
+  program.option("--memory-id <id>", "Memory ID for scoping");
+  const DEFAULT_LLM_MODEL = "gpt-4o";
+  const callAskAPI = async (prompt, memoryId) => {
+    const config = await getConfig();
+    const response = await fetch(`${config.baseUrl}/ask`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${config.apiKey}`
+      },
+      body: JSON.stringify({
+        prompt,
+        memory_id: memoryId,
+        llm_model: DEFAULT_LLM_MODEL
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP error: ${response.status} ${response.statusText}`);
     }
-    const userMessage = { role: "user", content: input };
-    const enhancedMessages = enhanceMessagesWithMemory([userMessage], { results: memoryContext.results });
-    const response = await _callProviderAPI(enhancedMessages, {
-      temperature: 0.7,
-      maxTokens: 1e3
-    }, options.provider);
+    const data = await response.json();
+    return data.response;
+  };
+  const processUserInput = async (input, options, isInteractive = false) => {
+    const { memoryId, instruction } = await resolveMemoryId({ memoryId: options.memoryId });
+    const response = await callAskAPI(input, memoryId);
     if (isInteractive) {
       console.log(`Assistant: ${response}`);
     } else {
       console.log(response);
     }
-    if (memoryContext.instruction) {
+    if (instruction) {
       console.log(`
-${memoryContext.instruction}`);
+${instruction}`);
     }
-    addMemories(input, { memoryId: memoryContext.memoryId }).catch((err) => {
+    addMemories(input, { memoryId }).catch((err) => {
       console.error("Failed to save memory:", err);
     });
-    return { response, instruction: memoryContext.instruction, memoryId: memoryContext.memoryId };
+    return { response, instruction, memoryId };
   };
   program.argument("[prompt]", "initial prompt for chat session (optional)").action(async (initialPrompt, options) => {
     try {
@@ -358,8 +282,16 @@ ${memoryContext.instruction}`);
         input: process.stdin,
         output: process.stdout
       });
+      const getPrompt = async () => {
+        if (!memoryId) {
+          const resolved = await resolveMemoryId({ memoryId: options.memoryId });
+          memoryId = resolved.memoryId;
+        }
+        return chalk.cyan(`[${memoryId}] > `);
+      };
       const chatLoop = async () => {
-        rl.question(chalk.cyan("> "), async (input) => {
+        const prompt = await getPrompt();
+        rl.question(prompt, async (input) => {
           if (input.toLowerCase() === "exit" || input.toLowerCase() === "quit") {
             console.log("Goodbye!");
             rl.close();
@@ -378,7 +310,9 @@ ${memoryContext.instruction}`);
           chatLoop();
         });
       };
-      console.log('\nEntering interactive mode. Type "exit" or "quit" to end the session.\n');
+      console.log(chalk.magenta("\nSatori is memory for AI. It remembers your sessions forever. Think of it like 'infinite context' for AI.\n"));
+      console.log(chalk.cyan("You're in interactive mode. Use interactive mode just like you would use ChatGPT."));
+      console.log(chalk.cyan('Type "exit" or "quit" to end the session.\n'));
       chatLoop();
     } catch (error) {
       console.error("Chat error:", error instanceof Error ? error.message : error);
@@ -391,6 +325,20 @@ ${memoryContext.instruction}`);
   program.command("search").description("search memories").argument("<query>", "search query for memories").action(async (query) => {
     await searchMemories(query);
   });
+  program.command("get").description("get config value").argument("<key>", "key to get").action(async (key) => {
+    if (key !== "apikey") {
+      console.error("Unknown key");
+      process.exit(1);
+    }
+    const apiKey = await getStoredApiKey();
+    if (!apiKey) {
+      console.error("API key not found in config");
+      process.exit(1);
+    }
+    console.log(chalk.magenta(`
+    ${apiKey}    
+`));
+  });
   program.parse();
 }
 var entryPath = process.argv[1] ? realpathSync(process.argv[1]) : "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@satori-sh/cli",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "CLI tool for Satori memory server",
   "type": "module",
   "main": "./dist/index.js",
@@ -19,6 +19,7 @@
     "logo.txt"
   ],
   "dependencies": {
+    "@opentui/core": "^0.1.73",
     "chalk": "^5.6.2",
     "commander": "^12.1.0",
     "random-words": "^2.0.1"