@astra-code/astra-ai 0.1.0

package/src/lib/voice.ts

@@ -0,0 +1,178 @@
+import {spawn, spawnSync} from "child_process";
+import {randomUUID} from "crypto";
+import {basename, join} from "path";
+import {tmpdir} from "os";
+import {readFile, rm} from "fs/promises";
+
+const VOICE_TEXT_LIMIT = 600;
+const DEFAULT_STT_MODEL = process.env.ASTRA_STT_MODEL?.trim() || "whisper-1";
+const DEFAULT_CHUNK_SECONDS = Number(process.env.ASTRA_STT_CHUNK_SECONDS ?? "2.5");
+
+const safeText = (text: string): string => text.replace(/\s+/g, " ").trim().slice(0, VOICE_TEXT_LIMIT);
+
+const runShell = async (command: string): Promise<void> =>
+  new Promise((resolve, reject) => {
+    const child = spawn(command, {shell: true, stdio: "ignore"});
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Command failed (${code}): ${command}`));
+      }
+    });
+  });
+
+const captureAudioChunk = async (seconds: number): Promise<string> => {
+  const outPath = join(tmpdir(), `astra-stt-${randomUUID()}.wav`);
+  const custom = process.env.ASTRA_STT_CAPTURE_COMMAND?.trim();
+
+  let cmd = custom ?? "";
+  if (!cmd) {
+    if (process.platform === "darwin") {
+      cmd = `sox -q -d -r 16000 -c 1 -b 16 "${outPath}" trim 0 ${seconds}`;
+    } else if (process.platform === "linux") {
+      cmd = `arecord -q -f S16_LE -r 16000 -c 1 -d ${Math.ceil(seconds)} "${outPath}"`;
+    } else {
+      throw new Error("No default audio capture command for this platform. Set ASTRA_STT_CAPTURE_COMMAND.");
+    }
+  } else {
+    cmd = cmd.replaceAll("{output}", outPath).replaceAll("{seconds}", String(seconds));
+  }
+
+  await runShell(cmd);
+  return outPath;
+};
+
+const transcribeAudioFile = async (filePath: string): Promise<string> => {
+  const apiKey = process.env.ASTRA_OPENAI_API_KEY?.trim() || process.env.OPENAI_API_KEY?.trim();
+  if (!apiKey) {
+    throw new Error("Missing OPENAI_API_KEY (or ASTRA_OPENAI_API_KEY) for Whisper STT.");
+  }
+
+  const bytes = await readFile(filePath);
+  const file = new File([bytes], basename(filePath), {type: "audio/wav"});
+  const form = new FormData();
+  form.append("file", file);
+  form.append("model", DEFAULT_STT_MODEL);
+  form.append("response_format", "json");
+
+  const response = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+    method: "POST",
+    headers: {Authorization: `Bearer ${apiKey}`},
+    body: form
+  });
+
+  if (!response.ok) {
+    const detail = (await response.text()).slice(0, 400);
+    throw new Error(`Whisper STT failed ${response.status}: ${detail}`);
+  }
+
+  const data = (await response.json()) as {text?: string};
+  return String(data.text ?? "").trim();
+};
+
+/**
+ * Speak assistant text using either:
+ * - ASTRA_TTS_COMMAND (shell command, receives text as final arg), or
+ * - macOS `say` by default.
+ */
+export const speakText = (text: string): void => {
+  const clean = safeText(text);
+  if (!clean) {
+    return;
+  }
+
+  const custom = process.env.ASTRA_TTS_COMMAND?.trim();
+  if (custom) {
+    spawn(custom, [clean], {shell: true, detached: true, stdio: "ignore"}).unref();
+    return;
+  }
+
+  if (process.platform === "darwin") {
+    spawn("say", [clean], {detached: true, stdio: "ignore"}).unref();
+  }
+};
+
+/**
+ * Run one-shot STT. Uses custom ASTRA_STT_COMMAND if provided;
+ * otherwise records a short chunk and transcribes via OpenAI Whisper.
+ */
+export const transcribeOnce = async (): Promise<string | null> => {
+  const sttCommand = process.env.ASTRA_STT_COMMAND?.trim();
+  if (sttCommand) {
+    const result = spawnSync(sttCommand, {shell: true, encoding: "utf-8"});
+    if (result.error || result.status !== 0) {
+      return null;
+    }
+    const out = String(result.stdout ?? "").trim();
+    return out || null;
+  }
+
+  let audioPath: string | null = null;
+  try {
+    audioPath = await captureAudioChunk(DEFAULT_CHUNK_SECONDS);
+    const text = await transcribeAudioFile(audioPath);
+    return text || null;
+  } catch {
+    return null;
+  } finally {
+    if (audioPath) {
+      await rm(audioPath, {force: true});
+    }
+  }
+};
+
+export type LiveTranscriptionController = {
+  stop: () => Promise<void>;
+};
+
+export const startLiveTranscription = (handlers: {
+  onPartial: (text: string) => void;
+  onFinal: (text: string) => void;
+  onError: (error: Error) => void;
+}): LiveTranscriptionController => {
+  let running = true;
+  let stopping = false;
+  let transcript = "";
+  let finishedResolve: (() => void) | null = null;
+  const finished = new Promise<void>((resolve) => {
+    finishedResolve = resolve;
+  });
+
+  const loop = async (): Promise<void> => {
+    while (running) {
+      let audioPath: string | null = null;
+      try {
+        audioPath = await captureAudioChunk(DEFAULT_CHUNK_SECONDS);
+        const piece = await transcribeAudioFile(audioPath);
+        if (piece) {
+          transcript = transcript ? `${transcript} ${piece}` : piece;
+          handlers.onPartial(transcript);
+        }
+      } catch (error) {
+        handlers.onError(error instanceof Error ? error : new Error(String(error)));
+      } finally {
+        if (audioPath) {
+          await rm(audioPath, {force: true});
+        }
+      }
+    }
+    handlers.onFinal(transcript.trim());
+    finishedResolve?.();
+  };
+
+  void loop();
+
+  return {
+    stop: async () => {
+      if (stopping) {
+        await finished;
+        return;
+      }
+      stopping = true;
+      running = false;
+      await finished;
+    }
+  };
+};

package/src/lib/workspaceScanner.ts

@@ -0,0 +1,177 @@
+/**
+ * Scans a local workspace directory to produce:
+ *   workspaceTree   — relative paths the backend uses for list_directory / search_files
+ *   workspaceFiles  — file contents the backend populates into VirtualFS
+ *                     so view_file / edit_file work without a local disk on the backend
+ */
+import {existsSync, readdirSync, readFileSync, statSync} from "fs";
+import {join, relative} from "path";
+
+export type WorkspaceFile = {
+  path: string;
+  content: string;
+  language: string;
+};
+
+const SKIP_DIRS = new Set([
+  "node_modules",
+  ".git",
+  ".svn",
+  ".hg",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  "__pycache__",
+  ".cache",
+  "coverage",
+  ".nyc_output",
+  "vendor",
+  ".venv",
+  "venv",
+  "env",
+  ".tox",
+  "target",
+  ".gradle",
+  ".idea",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".ruff_cache",
+]);
+
+const BINARY_EXTENSIONS = new Set([
+  ".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".bmp",
+  ".woff", ".woff2", ".ttf", ".eot", ".otf",
+  ".mp3", ".mp4", ".wav", ".webm", ".ogg", ".flac",
+  ".zip", ".tar", ".gz", ".br", ".zst", ".bz2", ".7z", ".rar",
+  ".pyc", ".pyo", ".class", ".o", ".so", ".dll", ".dylib",
+  ".exe", ".bin", ".pdf", ".sqlite", ".db",
+]);
+
+const EXT_TO_LANG: Record<string, string> = {
+  ".py": "python",
+  ".js": "javascript",
+  ".ts": "typescript",
+  ".tsx": "typescriptreact",
+  ".jsx": "javascriptreact",
+  ".json": "json",
+  ".md": "markdown",
+  ".css": "css",
+  ".scss": "scss",
+  ".less": "less",
+  ".html": "html",
+  ".xml": "xml",
+  ".rs": "rust",
+  ".go": "go",
+  ".java": "java",
+  ".c": "c",
+  ".cpp": "cpp",
+  ".h": "c",
+  ".rb": "ruby",
+  ".sh": "shellscript",
+  ".bash": "shellscript",
+  ".zsh": "shellscript",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".toml": "toml",
+  ".sql": "sql",
+  ".swift": "swift",
+  ".kt": "kotlin",
+  ".php": "php",
+  ".graphql": "graphql",
+  ".vue": "vue",
+  ".svelte": "svelte",
+  ".env": "plaintext",
+  ".txt": "plaintext",
+  ".csv": "plaintext",
+  ".lock": "plaintext",
+};
+
+const MAX_TREE_ENTRIES = 2000;
+const MAX_CONTENT_FILES = 200;
+const MAX_FILE_BYTES = 100 * 1024;    // 100 KB per file
+const MAX_TOTAL_BYTES = 2 * 1024 * 1024; // 2 MB total content
+
+function detectLanguage(relPath: string): string {
+  const m = relPath.toLowerCase().match(/\.[^./\\]+$/);
+  return m ? (EXT_TO_LANG[m[0]] ?? "plaintext") : "plaintext";
+}
+
+function isBinary(relPath: string): boolean {
+  const m = relPath.toLowerCase().match(/\.[^./\\]+$/);
+  return m ? BINARY_EXTENSIONS.has(m[0]) : false;
+}
+
+/**
+ * Scan `rootDir` and return both the path tree and file contents.
+ *
+ * Called once per `streamChat` request so the backend VirtualFS is always
+ * populated with the current state of the local workspace.
+ */
+export function scanWorkspace(rootDir: string): {
+  workspaceTree: string[];
+  workspaceFiles: WorkspaceFile[];
+} {
+  if (!existsSync(rootDir)) {
+    return {workspaceTree: [], workspaceFiles: []};
+  }
+
+  const workspaceTree: string[] = [];
+  const workspaceFiles: WorkspaceFile[] = [];
+  let totalBytes = 0;
+
+  function walk(dir: string): void {
+    if (workspaceTree.length >= MAX_TREE_ENTRIES) return;
+
+    let entries: string[];
+    try {
+      entries = readdirSync(dir).sort();
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (workspaceTree.length >= MAX_TREE_ENTRIES) break;
+
+      const fullPath = join(dir, entry);
+      const relPath = relative(rootDir, fullPath).replace(/\\/g, "/");
+
+      let st;
+      try {
+        st = statSync(fullPath);
+      } catch {
+        continue;
+      }
+
+      if (st.isDirectory()) {
+        if (SKIP_DIRS.has(entry) || entry.startsWith(".")) continue;
+        workspaceTree.push(relPath + "/");
+        walk(fullPath);
+      } else if (st.isFile()) {
+        workspaceTree.push(relPath);
+
+        if (
+          workspaceFiles.length < MAX_CONTENT_FILES &&
+          totalBytes < MAX_TOTAL_BYTES &&
+          !isBinary(relPath) &&
+          st.size < MAX_FILE_BYTES
+        ) {
+          try {
+            const content = readFileSync(fullPath, "utf-8");
+            workspaceFiles.push({
+              path: relPath,
+              content,
+              language: detectLanguage(relPath),
+            });
+            totalBytes += st.size;
+          } catch {
+            // Unreadable file — include in tree but skip content.
+          }
+        }
+      }
+    }
+  }
+
+  walk(rootDir);
+  return {workspaceTree, workspaceFiles};
+}

package/src/types/events.ts

@@ -0,0 +1,33 @@
+export type AuthSession = {
+  user_id: string;
+  org_id: string;
+  email?: string;
+  [key: string]: unknown;
+};
+
+export type ChatMessage = {
+  role: "user" | "assistant";
+  content: string;
+};
+
+export type AgentEvent =
+  | {type: "text"; content?: string}
+  | {type: "thinking"; content?: string}
+  | {type: "tool_start"; tool?: {name?: string}}
+  | {
+      type: "tool_result";
+      success?: boolean;
+      tool_name?: string;
+      data?: Record<string, unknown>;
+      error?: string;
+    }
+  | {
+      type: "run_in_terminal";
+      terminal_id?: string;
+      command?: string;
+      cwd?: string;
+      blocking?: boolean;
+    }
+  | {type: "credits_update"; remaining?: number; cost?: number}
+  | {type: "credits_exhausted"; message?: string}
+  | {type: "error"; error?: string; content?: string};

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist",
+    "module": "nodenext",
+    "target": "es2022",
+    "types": ["node"],
+    "sourceMap": true,
+    "declaration": false,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "strict": true,
+    "jsx": "react-jsx",
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "nodenext"
+  },
+  "include": ["src"]
+}