aryx-cli 1.0.0

package/src/screens/SetupScreen.tsx

@@ -0,0 +1,85 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import ThemeSelector from '../components/ThemeSelector.js';
+import { theme, markSetupDone } from '../theme.js';
+import { BRAND_NAME, VERSION } from '../constants.js';
+
+const SECURITY_NOTES = [
+  { title: `${BRAND_NAME} can make mistakes`, desc: `You should always review ${BRAND_NAME}'s responses, especially when running code.` },
+  { title: `${BRAND_NAME} executes commands carefully, but responsibility is yours`, desc: 'You should always review and verify code before running it, especially if it modifies files or installs dependencies.' },
+];
+
+const BANNER = [
+  '   █████╗ ██████╗ ██╗   ██╗██╗  ██╗',
+  '  ██╔══██╗██╔══██╗╚██╗ ██╔╝╚██╗██╔╝',
+  '  ███████║██████╔╝ ╚████╔╝  ╚███╔╝ ',
+  '  ██║  ██║██║  ██║   ██║   ██╔╝ ██╗',
+  '  ╚═╝  ╚═╝╚═╝  ╚═╝   ╚═╝   ╚═╝  ╚═╝',
+];
+
+const BannerHeader: React.FC<{ showTagline?: boolean }> = ({ showTagline }) => (
+  <Box flexDirection="column" paddingX={1} paddingTop={1} marginBottom={1}>
+    <Text>
+      <Text color={theme.colors.primary}>Welcome to {BRAND_NAME} </Text>
+      <Text color="gray">v{VERSION}</Text>
+    </Text>
+    <Box flexDirection="column" marginTop={1}>
+      {BANNER.map((line, i) => (
+        <Text key={i} color={theme.colors.primary}>{line}</Text>
+      ))}
+    </Box>
+    {showTagline && <Box paddingTop={1}><Text color="gray">Let's get started.</Text></Box>}
+  </Box>
+);
+
+const SetupScreen: React.FC<{ onComplete: () => void }> = ({ onComplete }) => {
+  const [phase, setPhase] = useState<'theme' | 'security'>('theme');
+
+  useInput((_, key) => {
+    if (phase === 'security' && key.return) {
+      markSetupDone();
+      onComplete();
+    }
+  });
+
+  return (
+    <Box 
+      key={phase} 
+      flexDirection="column">
+      <BannerHeader showTagline={phase === 'theme'} />
+      
+      {phase === 'theme' ? (
+        <ThemeSelector 
+          onClose={() => setPhase('security')} 
+          isSetup />
+      ) : (
+        <Box 
+          flexDirection="column" 
+          paddingX={2} 
+          marginTop={1}>
+          <Text bold>Security notes:</Text>
+
+          <Box flexDirection="column" marginTop={1}>
+            {SECURITY_NOTES.map((note, i) => (
+              <Box key={i} marginTop={i > 0 ? 1 : 0}>
+                <Text>{i + 1}. </Text>
+                
+                <Box flexDirection="column">
+                  <Text bold>{note.title}</Text>
+                  <Text color="gray">{note.desc}</Text>
+                </Box>
+              </Box>
+            ))}
+          </Box>
+
+          <Box marginTop={1}>
+            <Text color={theme.colors.primary}>Press <Text bold>Enter</Text> to continue...</Text>
+          </Box>
+        </Box>
+      )}
+    </Box>
+  );
+
+};
+
+export default SetupScreen;

package/src/services/ai.ts

@@ -0,0 +1,187 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { FILE_TOOLS, executeTool, formatDiff } from './fileTools.js';
+import { BRAND_NAME_LOWER, OPENROUTER_API_KEY, OPENROUTER_API_KEY_BACKUP, OPENROUTER_MODEL } from '../constants.js';
+
+const FILE_WRITE_TOOLS = new Set(['create_file', 'write_file', 'edit_file', 'append_file']);
+
+export interface ChatCompletionRequest {
+  messages: { role: 'user' | 'assistant'; content: string }[];
+}
+
+export interface UsageData {
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+  cost: number;
+  model: string;
+  responseTimeMs: number;
+}
+
+export interface ChatCompletionResponse {
+  content: string;
+  usage?: UsageData;
+}
+
+const OPENROUTER_URL = 'https://openrouter.ai/api/v1/chat/completions';
+
+const getConfig = () => {
+  return {
+    apiKey: OPENROUTER_API_KEY,
+    backupKey: OPENROUTER_API_KEY_BACKUP || undefined,
+    model: OPENROUTER_MODEL,
+  };
+};
+
+type OpenRouterMessage = {
+  content?: string | Array<{ text?: string }>;
+  tool_calls?: Array<{ id: string; function: { name: string; arguments: string } }>;
+};
+
+type OpenRouterResponse = {
+  error?: { message?: string };
+  choices?: Array<{ message?: OpenRouterMessage }>;
+  usage?: { prompt_tokens?: number; completion_tokens?: number; total_tokens?: number; cost?: number };
+  model?: string;
+};
+
+const extractContent = (data: OpenRouterResponse): string => {
+  const content = data.choices?.[0]?.message?.content;
+
+  if (typeof content === 'string') return content.trim();
+
+  if (Array.isArray(content)) {
+    return content.map((item) => item.text || '').join('').trim();
+  }
+
+  return '';
+};
+
+const fetchOpenRouter = async (messages: object[], apiKey: string, model: string, backupKey?: string) => {
+  const t0 = Date.now();
+
+  const tryFetch = async (key: string) => {
+    const res = await fetch(OPENROUTER_URL, {
+      method: 'POST',
+      headers: { 
+        authorization: `Bearer ${key}`, 
+        'content-type': 'application/json' 
+      },
+      body: JSON.stringify({ model, messages, tools: FILE_TOOLS }),
+    });
+
+    const data = await res.json() as OpenRouterResponse;
+    return { res, data };
+  };
+
+  let { res, data } = await tryFetch(apiKey);
+
+  if (!res.ok && backupKey) {
+    ({ res, data } = await tryFetch(backupKey));
+  }
+
+  if (!res.ok) {
+    throw new Error(data.error?.message || `OpenRouter failed (${res.status})`);
+  }
+
+  return { 
+    message: data.choices?.[0]?.message, 
+    usage: data.usage, 
+    model: data.model, 
+    responseTimeMs: Date.now() - t0 
+  };
+};
+
+export const chatService = {
+  fetchResponse: async (request: ChatCompletionRequest): Promise<ChatCompletionResponse> => {
+    const { apiKey, backupKey, model } = getConfig();
+
+    const messages: object[] = [
+      { role: 'system', content: `You are a helpful AI with file system access. CWD: ${process.cwd()}
+
+## About the Creator
+${BRAND_NAME_LOWER} CLI was created by Vasu Bhalodiya.
+- Full Name: Vasu Bhalodiya
+- Age: 20
+- Location: Rajkot, Gujarat, India
+- Role: Frontend Developer
+- Company: Prolix Technikos
+- Tech Stack: React.js, Next.js, JavaScript, TypeScript, TailwindCSS
+- GitHub: https://github.com/vasubhalodiya
+- LinkedIn: https://www.linkedin.com/in/vasubhalodiya
+- Portfolio: https://www.vasubhalodiya.in
+
+If anyone asks about "Vasu", "Vasu Bhalodiya", or the creator/developer of ${BRAND_NAME_LOWER}, provide the above information.` },
+      ...request.messages,
+    ];
+
+    // filePath -> content BEFORE any changes this session
+    const originals = new Map<string, string>();
+    let lastUsage: UsageData | undefined;
+
+    for (let i = 0; i < 10; i++) {
+      const { 
+        message: msg, 
+        usage, 
+        model: respModel, 
+        responseTimeMs 
+      } = await fetchOpenRouter(messages, apiKey, model, backupKey);
+
+      if (!msg) throw new Error('Empty response');
+      messages.push(msg);
+
+      if (usage) {
+        lastUsage = {
+          inputTokens: usage.prompt_tokens ?? 0,
+          outputTokens: usage.completion_tokens ?? 0,
+          totalTokens: usage.total_tokens ?? 0,
+          cost: usage.cost ?? 0,
+          model: respModel ?? model,
+          responseTimeMs,
+        };
+      }
+
+      if (!msg.tool_calls?.length) {
+        // Build one diff per changed file
+        const diffs: string[] = [];
+
+        for (const [fp, oldContent] of originals) {
+          const newContent = existsSync(fp) ? readFileSync(fp, 'utf8') : '';
+          
+          if (newContent !== oldContent) {
+            diffs.push(formatDiff(fp, oldContent, newContent));
+          }
+        }
+        
+        const aiText = extractContent({ choices: [{ message: msg }] }) || 'Done.';
+        const prefix = diffs.join('\n\n');
+
+        return { 
+          content: prefix ? prefix + '\n\n' + aiText : aiText, 
+          usage: lastUsage 
+        };
+      }
+
+      for (const tc of msg.tool_calls) {
+        const args = JSON.parse(tc.function.arguments || '{}');
+
+        // Snapshot original content before first write to this file
+        if (FILE_WRITE_TOOLS.has(tc.function.name) && args.file_path) {
+          const fp = resolve(process.cwd(), args.file_path);
+          if (!originals.has(fp)) {
+            originals.set(fp, existsSync(fp) ? readFileSync(fp, 'utf8') : '');
+          }
+        }
+
+        const output = executeTool(tc.function.name, args);
+        messages.push({ role: 'tool', tool_call_id: tc.id, content: output });
+      }
+    }
+
+    return { 
+      content: 'Max iterations reached.', 
+      usage: lastUsage 
+    };
+  },
+};
+

package/src/services/auth.ts

@@ -0,0 +1,100 @@
+import { existsSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { readConfig, writeConfig } from './config.js';
+import { FIREBASE_API_KEY } from '../constants.js';
+
+const CFG = join(homedir(), '.aryx', 'config.json');
+
+export type AuthData = {
+  uid: string;
+  email: string;
+  displayName: string;
+  photoURL: string;
+  idToken: string;
+  refreshToken: string;
+  idTokenExpiry: number;
+};
+
+export const readAuth = (): AuthData | null => {
+  const cfg = readConfig();
+  const auth = cfg.auth as AuthData | undefined;
+
+  if (!auth?.uid) return null;
+
+  return auth;
+};
+
+export const saveAuth = (data: AuthData): void => {
+  writeConfig({ 
+    ...readConfig(), 
+    auth: data 
+  });
+};
+
+export const clearAuth = (): void => {
+  const cfg = readConfig();
+  delete cfg.auth;
+
+  writeConfig(cfg);
+};
+
+export const deleteConfig = (): void => {
+  try { 
+    if (existsSync(CFG)) {
+      unlinkSync(CFG);
+    }
+  } catch { 
+    // Ignore errors
+  }
+};
+
+export const isLoggedIn = (): boolean => {
+  return readAuth() !== null;
+};
+
+export const getValidToken = async (): Promise<string | null> => {
+  const auth = readAuth();
+  if (!auth) return null;
+
+  if (Date.now() < auth.idTokenExpiry) {
+    return auth.idToken;
+  }
+
+  // idToken expired — refresh via Firebase REST API
+  try {
+    const apiKey = FIREBASE_API_KEY;
+
+    const res = await fetch(
+      `https://securetoken.googleapis.com/v1/token?key=${apiKey}`,
+      {
+        method: 'POST',
+        headers: { 
+          'Content-Type': 'application/x-www-form-urlencoded' 
+        },
+        body: `grant_type=refresh_token&refresh_token=${encodeURIComponent(auth.refreshToken)}`,
+      }
+    );
+
+    if (!res.ok) {
+      clearAuth();
+      return null;
+    }
+
+    const json = await res.json() as { id_token: string; refresh_token: string };
+
+    const updated: AuthData = {
+      ...auth,
+      idToken: json.id_token,
+      refreshToken: json.refresh_token,
+      idTokenExpiry: Date.now() + 3_600_000,
+    };
+
+    saveAuth(updated);
+
+    return updated.idToken;
+  } catch {
+    return null;
+  }
+};
+

package/src/services/config.ts

@@ -0,0 +1,30 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const CONFIG_DIR = join(homedir(), '.aryx');
+const CONFIG_PATH = join(CONFIG_DIR, 'config.json');
+
+/** Read the shared config file (~/.aryx/config.json). */
+export const readConfig = (): Record<string, unknown> => {
+  try {
+    if (existsSync(CONFIG_PATH)) {
+      return JSON.parse(readFileSync(CONFIG_PATH, 'utf8'));
+    }
+  } catch { 
+    /* corrupted / unreadable — treat as empty */ 
+  }
+
+  return {};
+};
+
+/** Write the shared config file (~/.aryx/config.json). */
+export const writeConfig = (data: Record<string, unknown>): void => {
+  try {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(CONFIG_PATH, JSON.stringify(data));
+  } catch { 
+    /* permission error — silently ignore */ 
+  }
+};
+

package/src/services/fileTools.ts

@@ -0,0 +1,257 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import chalk from 'chalk';
+import { diffLines } from 'diff';
+import { theme, DIFF_COLORS } from '../theme.js';
+
+type Args = Record<string, string>;
+type Tool = { description: string; params: string[]; optional?: string[]; handler: (a: Args) => string };
+
+// ─── Diff Engine ─────────────────────────────────────────────────────────────
+
+const formatDiff = (fp: string, oldSrc: string, newSrc: string): string => {
+  const rel = path.relative(process.cwd(), fp).replace(/\\/g, '/');
+  const { add: addClr, rm: rmClr } = DIFF_COLORS[theme.diffTheme];
+  const useBg = theme.diffTheme <= 2;
+  const isNew = !oldSrc;
+
+  type Op = { t: 's' | 'a' | 'r'; l: string };
+
+  const ops: Op[] = diffLines(oldSrc || '', newSrc).flatMap(ch => {
+    const t = ch.added ? 'a' : ch.removed ? 'r' : 's';
+    const lines = ch.value.split('\n');
+
+    if (lines.at(-1) === '') lines.pop();
+
+    return lines.map(l => ({ t, l }) as Op);
+  });
+
+  const added = ops.filter(o => o.t === 'a').length;
+  const rem = ops.filter(o => o.t === 'r').length;
+
+  if (!added && !rem) return `No changes: ${rel}`;
+
+  // visible = changed ± 2 context lines
+  const vis = new Set<number>();
+  ops.forEach((o, i) => {
+    if (o.t !== 's') {
+      for (let c = Math.max(0, i - 2); c <= Math.min(ops.length - 1, i + 2); c++) {
+        vis.add(c);
+      }
+    }
+  });
+
+  const hdr = chalk.bold(`${isNew ? 'Create' : 'Update'}(${rel})`);
+  const sum = `   └─ Added ${added} lines${isNew ? '' : `, removed ${rem} lines`}`;
+  const body: string[] = [];
+  
+  let ol = 0, nl = 0, hidden = false;
+
+  ops.forEach((o, i) => {
+    if (o.t === 's') { 
+      ol++; 
+      nl++; 
+    } else if (o.t === 'r') {
+      ol++; 
+    } else {
+      nl++;
+    }
+
+    if (!vis.has(i)) { 
+      hidden = true; 
+      return; 
+    }
+
+    if (hidden) { 
+      body.push(chalk.gray('  ...')); 
+      hidden = false; 
+    }
+
+    const ln = String(o.t === 'a' ? nl : ol).padStart(4);
+
+    if (o.t === 's') {
+      body.push(chalk.gray(`  ${ln}  ${o.l}`));
+    } else if (o.t === 'r') {
+      body.push(useBg ? chalk.bgHex(rmClr).black(`- ${ln}  ${o.l}`) : chalk.hex(rmClr)(`- ${ln}  ${o.l}`));
+    } else {
+      body.push(useBg ? chalk.bgHex(addClr).black(`+ ${ln}  ${o.l}`) : chalk.hex(addClr)(`+ ${ln}  ${o.l}`));
+    }
+  });
+
+  return [hdr, sum, '', ...body].join('\n');
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+const r = (p: string) => path.resolve(process.cwd(), p || '.');
+const mk = (fp: string) => fs.mkdirSync(path.dirname(fp), { recursive: true });
+
+// ─── Add / remove tools here only ────────────────────────────────────────────
+
+const TOOLS: Record<string, Tool> = {
+
+  create_file: {
+    description: 'Create a new file with content (fails if already exists)',
+    params: ['file_path', 'content'],
+    handler: (a) => {
+      const fp = r(a.file_path);
+      mk(fp);
+
+      if (fs.existsSync(fp)) return `Already exists: ${fp}`;
+
+      fs.writeFileSync(fp, a.content, 'utf8');
+      return `Created: ${fp}`;
+    },
+  },
+
+  read_file: {
+    description: 'Read and return the full contents of a file',
+    params: ['file_path'],
+    handler: (a) => {
+      return fs.readFileSync(r(a.file_path), 'utf8');
+    },
+  },
+
+  write_file: {
+    description: 'Overwrite a file with new content (creates if missing)',
+    params: ['file_path', 'content'],
+    handler: (a) => { 
+      const fp = r(a.file_path); 
+      mk(fp); 
+      fs.writeFileSync(fp, a.content, 'utf8'); 
+
+      return `Written: ${fp}`; 
+    },
+  },
+
+  append_file: {
+    description: 'Append content to the end of a file',
+    params: ['file_path', 'content'],
+    handler: (a) => { 
+      const fp = r(a.file_path); 
+      mk(fp); 
+      fs.appendFileSync(fp, a.content, 'utf8'); 
+
+      return `Appended to: ${fp}`; 
+    },
+  },
+
+  edit_file: {
+    description: 'Find old_text in a file and replace it with new_text',
+    params: ['file_path', 'old_text', 'new_text'],
+    handler: (a) => {
+      const fp = r(a.file_path);
+      const src = fs.readFileSync(fp, 'utf8');
+
+      if (!src.includes(a.old_text)) return `Text not found in: ${fp}`;
+
+      fs.writeFileSync(fp, src.replace(a.old_text, a.new_text), 'utf8');
+      return `Edited: ${fp}`;
+    },
+  },
+
+  delete_file: {
+    description: 'Delete a single file',
+    params: ['file_path'],
+    handler: (a) => { 
+      fs.unlinkSync(r(a.file_path)); 
+      return `Deleted: ${a.file_path}`; 
+    },
+  },
+
+  copy_file: {
+    description: 'Copy a file from src path to dest path',
+    params: ['src', 'dest'],
+    handler: (a) => { 
+      const dest = r(a.dest); 
+      mk(dest); 
+      fs.copyFileSync(r(a.src), dest); 
+
+      return `Copied → ${dest}`; 
+    },
+  },
+
+  move_file: {
+    description: 'Move or rename a file from src to dest',
+    params: ['src', 'dest'],
+    handler: (a) => { 
+      const dest = r(a.dest); 
+      mk(dest); 
+      fs.renameSync(r(a.src), dest); 
+
+      return `Moved → ${dest}`; 
+    },
+  },
+
+  list_files: {
+    description: 'List files and folders in a directory',
+    params: [],
+    optional: ['dir_path'],
+    handler: (a) => {
+      const entries = fs.readdirSync(r(a.dir_path), { withFileTypes: true });
+
+      return entries
+        .map(e => `${e.isDirectory() ? '[dir] ' : '[file]'} ${e.name}`)
+        .join('\n') || '(empty)';
+    },
+  },
+
+  make_dir: {
+    description: 'Create a directory (and any missing parent directories)',
+    params: ['dir_path'],
+    handler: (a) => { 
+      fs.mkdirSync(r(a.dir_path), { recursive: true }); 
+      return `Directory created: ${a.dir_path}`; 
+    },
+  },
+
+  delete_dir: {
+    description: 'Recursively delete a directory and all its contents',
+    params: ['dir_path'],
+    handler: (a) => { 
+      fs.rmSync(r(a.dir_path), { recursive: true, force: true }); 
+      return `Directory deleted: ${a.dir_path}`; 
+    },
+  },
+
+  file_exists: {
+    description: 'Check whether a file or directory exists',
+    params: ['file_path'],
+    handler: (a) => {
+      return fs.existsSync(r(a.file_path)) 
+        ? `Exists: ${a.file_path}` 
+        : `Not found: ${a.file_path}`;
+    },
+  },
+
+};
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+// Auto-build OpenRouter tool definitions from TOOLS map
+export const FILE_TOOLS = Object.entries(TOOLS).map(([name, { description, params, optional = [] }]) => ({
+  type: 'function',
+  function: {
+    name,
+    description,
+    parameters: {
+      type: 'object',
+      properties: Object.fromEntries(
+        [...params, ...optional].map(k => [k, { type: 'string' }])
+      ),
+      required: params,
+    },
+  },
+}));
+
+export { formatDiff };
+
+// Auto-dispatch to handler
+export const executeTool = (name: string, args: Args): string => {
+  try {
+    return TOOLS[name]?.handler(args) ?? `Unknown tool: ${name}`;
+  } catch (e: any) {
+    return `Error: ${e.message}`;
+  }
+};
+