agent-termo 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-termo",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Terminal-based AI coding agent that replicates Claude Code experience",
   "type": "module",
   "main": "dist/main.js",
@@ -87,4 +87,4 @@
     ],
     "outputPath": "dist"
   }
-}
+}

package/src/cli.ts

@@ -5,25 +5,104 @@
 
 import { Command } from 'commander';
 import { runRepl } from './main.js';
+import { saveNimApiKey } from './utils/config.js';
 
 const program = new Command();
 
+async function promptForApiKey(): Promise<string> {
+  const input = process.stdin;
+  const output = process.stdout;
+
+  if (!input.isTTY || typeof input.setRawMode !== 'function') {
+    throw new Error(
+      'NVIDIA NIM API key is missing. Run Agent-Termo in an interactive terminal or set NIM_API_KEY before starting.',
+    );
+  }
+
+  console.log('An NVIDIA NIM API key is required to start Agent-Termo.');
+  console.log('Get your key at https://build.nvidia.com/');
+  output.write('Enter your API key (input hidden): ');
+
+  return new Promise((resolve, reject) => {
+    let apiKey = '';
+    let previousWasCarriageReturn = false;
+
+    const restoreTerminal = () => {
+      input.off('data', onData);
+      input.setRawMode(false);
+      input.pause();
+      output.write('\n');
+    };
+
+    const onData = (data: Buffer) => {
+      for (const char of data.toString('utf-8')) {
+        if (char === '\n' && previousWasCarriageReturn) {
+          previousWasCarriageReturn = false;
+          continue;
+        }
+        previousWasCarriageReturn = char === '\r';
+
+        if (char === '\u0003' || char === '\u0004') {
+          restoreTerminal();
+          reject(new Error('API key setup cancelled.'));
+          return;
+        }
+
+        if (char === '\r' || char === '\n') {
+          if (!apiKey.trim()) {
+            output.write('\nAn API key is required. Enter your API key: ');
+            continue;
+          }
+
+          restoreTerminal();
+          resolve(apiKey.trim());
+          return;
+        }
+
+        if (char === '\u007f' || char === '\b') {
+          apiKey = apiKey.slice(0, -1);
+        } else if (char >= ' ') {
+          apiKey += char;
+        }
+      }
+    };
+
+    input.setRawMode(true);
+    input.resume();
+    input.on('data', onData);
+  });
+}
+
+async function startAgent(
+  project: string,
+  options: { apiKey?: string; model?: string; debug?: boolean },
+): Promise<void> {
+  // Apply CLI overrides to env before main initializes.
+  if (options.apiKey) process.env.NIM_API_KEY = options.apiKey;
+  if (options.model) process.env.NIM_MODEL = options.model;
+  if (options.debug) process.env.LOG_LEVEL = 'debug';
+
+  if (!process.env.NIM_API_KEY?.trim()) {
+    const apiKey = await promptForApiKey();
+    saveNimApiKey(apiKey);
+    process.env.NIM_API_KEY = apiKey;
+    console.log('API key saved. Agent-Termo will remember it for future sessions.');
+  }
+
+  console.log(`Starting Agent-Termo in: ${project}`);
+  await runRepl(project);
+}
+
 program
   .name('agent-termo')
   .description('Terminal AI coding agent with Nvidia NIM APIs')
-  .version('1.0.0')
+  .version('1.0.1')
   .argument('[project]', 'Project directory to operate in', process.cwd())
   .option('-k, --api-key <key>', 'Nvidia NIM API key')
   .option('-m, --model <model>', 'Model name to use')
   .option('--debug', 'Enable debug logging')
   .action(async (project: string, options: { apiKey?: string; model?: string; debug?: boolean }) => {
-    // Apply CLI overrides to env before main initializes
-    if (options.apiKey) process.env.NIM_API_KEY = options.apiKey;
-    if (options.model) process.env.NIM_MODEL = options.model;
-    if (options.debug) process.env.LOG_LEVEL = 'debug';
-
-    console.log(`Starting Agent-Termo in: ${project}`);
-    await runRepl(project);
+    await startAgent(project, options);
   });
 
 program
@@ -56,14 +135,14 @@ program
 
     console.log(`\n✓ Initialized Agent-Termo in ${resolve(dir)}`);
     console.log('  Created: docs/MEMORY.md, docs/TIMELINE.md');
-    console.log('  Create a .env file with your NIM_API_KEY to get started.');
+    console.log('  Agent-Termo will ask for your NVIDIA NIM API key the first time you launch it.');
   });
 
 async function main() {
-  // Check for unparsed arguments — if none, run repl mode
+  // Run REPL mode directly when no command or options are supplied.
   const args = process.argv.slice(2);
   if (args.length === 0) {
-    await runRepl(process.cwd());
+    await startAgent(process.cwd(), {});
     return;
   }
 
@@ -73,4 +152,4 @@ async function main() {
 main().catch((err) => {
   console.error(`\nFatal error: ${err instanceof Error ? err.message : err}`);
   process.exit(1);
-});
+});

package/src/utils/config.ts

@@ -2,7 +2,7 @@
 // Config Management
 // =============================================================================
 
-import { readFileSync } from 'node:fs';
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import type { AppConfig } from '../types/index.js';
@@ -52,6 +52,49 @@ export function getAgentTermoDir(): string {
   return resolve(process.env.HOME || process.env.USERPROFILE || '.', '.agent-termo');
 }
 
+function loadStoredNimApiKey(): void {
+  if (process.env.NIM_API_KEY) return;
+
+  try {
+    const stored = JSON.parse(
+      readFileSync(resolve(getAgentTermoDir(), 'config.json'), 'utf-8'),
+    ) as { nimApiKey?: unknown };
+
+    if (typeof stored.nimApiKey === 'string' && stored.nimApiKey.trim()) {
+      process.env.NIM_API_KEY = stored.nimApiKey;
+    }
+  } catch {
+    // No saved user configuration yet.
+  }
+}
+
+export function saveNimApiKey(apiKey: string): void {
+  const configDir = getAgentTermoDir();
+  const configPath = resolve(configDir, 'config.json');
+  let storedConfig: Record<string, unknown> = {};
+
+  try {
+    const existing: unknown = JSON.parse(readFileSync(configPath, 'utf-8'));
+    if (existing && typeof existing === 'object' && !Array.isArray(existing)) {
+      storedConfig = existing as Record<string, unknown>;
+    }
+  } catch {
+    // Create a new configuration file when one does not exist.
+  }
+
+  storedConfig.nimApiKey = apiKey;
+  mkdirSync(configDir, { recursive: true, mode: 0o700 });
+  writeFileSync(configPath, `${JSON.stringify(storedConfig, null, 2)}\n`, {
+    encoding: 'utf-8',
+    mode: 0o600,
+  });
+
+  // Restrict permissions even when updating an existing file on Unix.
+  if (process.platform !== 'win32') chmodSync(configPath, 0o600);
+}
+
+loadStoredNimApiKey();
+
 export function getConfig(projectRoot: string): AppConfig {
   loadEnvFile(resolve(projectRoot, '.env'));
 
@@ -72,4 +115,4 @@ export function getConfig(projectRoot: string): AppConfig {
 
 export function resolveProjectRoot(cwd?: string): string {
   return cwd || PROJECT_ROOT;
-}
+}