@ailog/cli 0.2.3 → 0.3.0

package/dist/index.js

@@ -0,0 +1,681 @@
+// src/db.ts
+import path from "path";
+import fs from "fs";
+var DB_DIR = path.join(process.cwd(), ".ailog");
+var RUNS_DIR = () => path.join(DB_DIR, "runs");
+var BLOBS_DIR = () => path.join(DB_DIR, "blobs");
+var RUN_INDEX_DIR = () => path.join(DB_DIR, "index", "runs");
+var THREAD_INDEX_DIR = () => path.join(DB_DIR, "index", "threads");
+var PAGE_SIZE = 50;
+var AILOG_PORT = process.env.AILOG_PORT ? parseInt(process.env.AILOG_PORT) : 4985;
+var dirResolved = false;
+var dirResolvePromise = null;
+var resolveDbDir = async () => {
+  if (dirResolved) return;
+  if (!dirResolvePromise) {
+    dirResolvePromise = (async () => {
+      try {
+        const res = await fetch(
+          `http://localhost:${AILOG_PORT}/api/db-dir`
+        );
+        if (res.ok) {
+          const body = await res.json();
+          if (typeof body.dir === "string" && body.dir.length > 0) {
+            DB_DIR = body.dir;
+          }
+        }
+      } catch {
+      } finally {
+        dirResolved = true;
+      }
+    })();
+  }
+  await dirResolvePromise;
+};
+var BLOB_THRESHOLD = 16 * 1024;
+var notifyServer = (event, runId) => {
+  notifyServerAsync(event, runId);
+};
+var notifyServerAsync = async (event, runId) => {
+  try {
+    await fetch(`http://localhost:${AILOG_PORT}/api/notify`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        event,
+        timestamp: Date.now(),
+        runId: runId ?? null
+      })
+    });
+  } catch {
+  }
+};
+var digitTimestamp = (date) => date.toISOString().replace(/[-:T.Z]/g, "").slice(0, 17);
+var generateRunId = () => {
+  const timestamp = digitTimestamp(/* @__PURE__ */ new Date());
+  const uniqueId = crypto.randomUUID().slice(0, 8);
+  return `${timestamp}-${uniqueId}`;
+};
+var ensureGitignore = () => {
+  const gitignorePath = path.join(process.cwd(), ".gitignore");
+  if (!fs.existsSync(gitignorePath)) return;
+  const content = fs.readFileSync(gitignorePath, "utf-8");
+  const alreadyIgnored = content.split("\n").some((line) => line.trim() === ".ailog" || line.trim() === ".ailog/");
+  if (!alreadyIgnored) {
+    const next = content.endsWith("\n") ? `${content}.ailog
+` : `${content}
+.ailog
+`;
+    fs.writeFileSync(gitignorePath, next);
+  }
+};
+var ensureLayout = () => {
+  const isFirstRun = !fs.existsSync(DB_DIR);
+  fs.mkdirSync(RUNS_DIR(), { recursive: true });
+  fs.mkdirSync(BLOBS_DIR(), { recursive: true });
+  fs.mkdirSync(RUN_INDEX_DIR(), { recursive: true });
+  fs.mkdirSync(THREAD_INDEX_DIR(), { recursive: true });
+  if (isFirstRun) ensureGitignore();
+};
+var atomicWrite = (filePath, data) => {
+  ensureLayout();
+  const tmp = `${filePath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 6)}.tmp`;
+  fs.writeFileSync(tmp, data);
+  fs.renameSync(tmp, filePath);
+};
+var safeReadJson = (filePath, fallback) => {
+  try {
+    if (!fs.existsSync(filePath)) return fallback;
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  } catch {
+    return fallback;
+  }
+};
+var blobPathFor = (stepId, field) => path.join("blobs", `${stepId}-${field}`);
+var writeBlob = (relPath, content) => {
+  ensureLayout();
+  atomicWrite(path.join(DB_DIR, relPath), content);
+};
+var externalizeIfLarge = (value, stepId, field) => {
+  if (value === void 0 || value === null) return null;
+  if (value.length < BLOB_THRESHOLD) return value;
+  const rel = blobPathFor(stepId, field);
+  writeBlob(rel, value);
+  return { $blob: rel };
+};
+var runCache = /* @__PURE__ */ new Map();
+var pageCache = /* @__PURE__ */ new Map();
+var PAGE_FILE_RE = /^\d{17}\.json$/;
+var nextPageFilePath = (dir) => {
+  let nowMs = Date.now();
+  const files = listPageFiles(dir);
+  if (files.length > 0) {
+    const latestName = path.basename(files[files.length - 1], ".json");
+    const latestMs = parseDigitTimestamp(latestName);
+    if (Number.isFinite(latestMs) && latestMs >= nowMs) nowMs = latestMs + 1;
+  }
+  return path.join(dir, digitTimestamp(new Date(nowMs)) + ".json");
+};
+var parseDigitTimestamp = (s) => {
+  if (!/^\d{17}$/.test(s)) return NaN;
+  const iso = s.slice(0, 4) + "-" + s.slice(4, 6) + "-" + s.slice(6, 8) + "T" + s.slice(8, 10) + ":" + s.slice(10, 12) + ":" + s.slice(12, 14) + "." + s.slice(14, 17) + "Z";
+  return new Date(iso).getTime();
+};
+var listPageFiles = (dir) => {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+  return entries.filter((n) => PAGE_FILE_RE.test(n)).sort().map((n) => path.join(dir, n));
+};
+var loadPage = (file) => {
+  const cached = pageCache.get(file);
+  if (cached) return cached;
+  const data = safeReadJson(file, []);
+  pageCache.set(file, data);
+  return data;
+};
+var writePage = (file, items) => {
+  atomicWrite(file, JSON.stringify(items));
+  pageCache.set(file, items);
+};
+var appendToLatestPage = (dir, item) => {
+  ensureLayout();
+  const files = listPageFiles(dir);
+  if (files.length === 0) {
+    writePage(nextPageFilePath(dir), [item]);
+    return;
+  }
+  const latest = files[files.length - 1];
+  const page = loadPage(latest);
+  if (page.length >= PAGE_SIZE) {
+    writePage(nextPageFilePath(dir), [item]);
+  } else {
+    writePage(latest, [...page, item]);
+  }
+};
+var updateInPlace = (dir, predicate, mutator) => {
+  const files = listPageFiles(dir).reverse();
+  for (const file of files) {
+    const page = loadPage(file);
+    const i = page.findIndex(predicate);
+    if (i === -1) continue;
+    const next = page.slice();
+    next[i] = mutator(page[i]);
+    writePage(file, next);
+    return true;
+  }
+  return false;
+};
+var loadRunFile = (runId) => {
+  const cached = runCache.get(runId);
+  if (cached) return cached;
+  const file = safeReadJson(
+    path.join(RUNS_DIR(), `${runId}.json`),
+    null
+  );
+  if (!file) return null;
+  runCache.set(runId, file);
+  return file;
+};
+var persistRunFile = (runId, file) => {
+  runCache.set(runId, file);
+  atomicWrite(path.join(RUNS_DIR(), `${runId}.json`), JSON.stringify(file));
+};
+var stepIsInProgress = (s) => s.duration_ms === null && !s.error;
+var extractFirstMessage = (rawInput) => {
+  try {
+    const parsed = JSON.parse(rawInput);
+    const messages = parsed?.prompt;
+    if (!Array.isArray(messages)) return null;
+    let lastUser;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const m = messages[i];
+      if (m?.role === "user") {
+        lastUser = m;
+        break;
+      }
+    }
+    if (!lastUser) return null;
+    const content = lastUser.content;
+    let text = "";
+    if (typeof content === "string") {
+      text = content;
+    } else if (Array.isArray(content)) {
+      const part = content.find(
+        (p) => p?.type === "text"
+      );
+      text = part?.text ?? "";
+    }
+    if (!text) return null;
+    return text.length > 60 ? text.slice(0, 60) + "..." : text;
+  } catch {
+    return null;
+  }
+};
+var recomputeSummary = (file) => {
+  const firstStep = file.steps[0];
+  const hasError = file.steps.some((s) => s.error !== null);
+  const isInProgress = file.steps.some(stepIsInProgress);
+  const firstMessage = firstStep ? extractFirstMessage(firstStep.input) : null;
+  return {
+    id: file.run.id,
+    started_at: file.run.started_at,
+    function_id: file.run.function_id,
+    thread_id: file.run.thread_id,
+    step_count: file.steps.length,
+    has_error: hasError,
+    is_in_progress: isInProgress,
+    first_message: firstMessage,
+    type: firstStep?.type ?? null
+  };
+};
+var upsertThread = (threadId, runStartedAt, metadata) => {
+  const updated = updateInPlace(
+    THREAD_INDEX_DIR(),
+    (t) => t.id === threadId,
+    (existing) => ({
+      ...existing,
+      updated_at: new Date(runStartedAt) > new Date(existing.updated_at) ? runStartedAt : existing.updated_at,
+      run_count: existing.run_count + 1
+    })
+  );
+  if (updated) return;
+  appendToLatestPage(THREAD_INDEX_DIR(), {
+    id: threadId,
+    created_at: runStartedAt,
+    updated_at: runStartedAt,
+    run_count: 1,
+    metadata: metadata && typeof metadata === "object" ? JSON.stringify(metadata) : null
+  });
+};
+var upsertSummary = (file) => {
+  const summary = recomputeSummary(file);
+  const updated = updateInPlace(
+    RUN_INDEX_DIR(),
+    (s) => s.id === summary.id,
+    () => summary
+  );
+  if (updated) return;
+  appendToLatestPage(RUN_INDEX_DIR(), summary);
+};
+var createRun = async (id, functionId, threadId, metadata) => {
+  await resolveDbDir();
+  ensureLayout();
+  const existing = loadRunFile(id);
+  if (existing) return existing.run;
+  const resolvedThreadId = threadId ?? `auto-${crypto.randomUUID().slice(0, 8)}`;
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const run = {
+    id,
+    started_at: startedAt,
+    function_id: functionId ?? null,
+    thread_id: resolvedThreadId
+  };
+  const file = { version: 1, run, steps: [] };
+  persistRunFile(id, file);
+  upsertSummary(file);
+  upsertThread(resolvedThreadId, startedAt, metadata);
+  notifyServer("run", id);
+  return run;
+};
+var createStep = async (step) => {
+  await resolveDbDir();
+  ensureLayout();
+  const file = loadRunFile(step.run_id);
+  if (!file) {
+    return 0;
+  }
+  const stepNumber = file.steps.length + 1;
+  const newStep = {
+    ...step,
+    step_number: stepNumber,
+    duration_ms: null,
+    output: null,
+    usage: null,
+    error: null,
+    raw_request: null,
+    raw_response: null,
+    raw_chunks: null
+  };
+  file.steps.push(newStep);
+  persistRunFile(file.run.id, file);
+  upsertSummary(file);
+  notifyServer("step", file.run.id);
+  return stepNumber;
+};
+var updateStepResult = async (stepId, result) => {
+  await resolveDbDir();
+  let file;
+  let step;
+  for (const cached of runCache.values()) {
+    const match = cached.steps.find((s) => s.id === stepId);
+    if (match) {
+      file = cached;
+      step = match;
+      break;
+    }
+  }
+  if (!file || !step) {
+    for (const pageFile of listPageFiles(RUN_INDEX_DIR())) {
+      for (const summary of loadPage(pageFile)) {
+        const candidate = loadRunFile(summary.id);
+        if (!candidate) continue;
+        const match = candidate.steps.find((s) => s.id === stepId);
+        if (match) {
+          file = candidate;
+          step = match;
+          break;
+        }
+      }
+      if (file) break;
+    }
+  }
+  if (!file || !step) return;
+  step.duration_ms = result.duration_ms;
+  step.usage = result.usage ?? null;
+  step.error = result.error ?? null;
+  step.output = externalizeIfLarge(result.output, stepId, "output");
+  step.raw_request = externalizeIfLarge(
+    result.raw_request,
+    stepId,
+    "raw_request"
+  );
+  step.raw_response = externalizeIfLarge(
+    result.raw_response,
+    stepId,
+    "raw_response"
+  );
+  step.raw_chunks = externalizeIfLarge(
+    result.raw_chunks,
+    stepId,
+    "raw_chunks"
+  );
+  persistRunFile(file.run.id, file);
+  upsertSummary(file);
+  notifyServer("step-update", file.run.id);
+};
+
+// src/middleware.ts
+var generateId = () => crypto.randomUUID();
+var activeSteps = /* @__PURE__ */ new Map();
+var signalHandlersRegistered = false;
+var registerSignalHandlers = () => {
+  if (signalHandlersRegistered) return;
+  signalHandlersRegistered = true;
+  const cleanup = async () => {
+    if (activeSteps.size === 0) return;
+    const promises = Array.from(activeSteps.entries()).map(
+      async ([stepId, data]) => {
+        const durationMs = Date.now() - data.startTime;
+        await updateStepResult(stepId, {
+          duration_ms: durationMs,
+          output: JSON.stringify(data.collectedOutput),
+          usage: null,
+          error: "Request aborted",
+          raw_request: data.request && typeof data.request === "object" && "body" in data.request ? JSON.stringify(data.request.body) : null,
+          raw_response: JSON.stringify(data.fullStreamChunks),
+          raw_chunks: JSON.stringify(data.rawChunks)
+        });
+      }
+    );
+    await Promise.all(promises);
+    await notifyServerAsync("step-update");
+  };
+  process.on("SIGINT", () => {
+    cleanup().then(() => process.exit(130));
+  });
+  process.on("SIGTERM", () => {
+    cleanup().then(() => process.exit(143));
+  });
+};
+var aiSdkMiddleware = (options = {}) => {
+  if (process.env.NODE_ENV === "production") {
+    throw new Error(
+      "ailog should not be used in production. Remove aiSdkMiddleware from your model configuration for production builds."
+    );
+  }
+  registerSignalHandlers();
+  const runId = generateRunId();
+  let runCreated = false;
+  const ensureRunCreated = async () => {
+    if (!runCreated) {
+      await createRun(
+        runId,
+        options.functionId,
+        options.threadId,
+        options.metadata
+      );
+      runCreated = true;
+    }
+  };
+  return {
+    specificationVersion: "v4",
+    wrapGenerate: async ({ doGenerate, params, model }) => {
+      const startTime = Date.now();
+      const stepId = generateId();
+      await ensureRunCreated();
+      await createStep({
+        id: stepId,
+        run_id: runId,
+        type: "generate",
+        model_id: model.modelId,
+        provider: model.provider,
+        started_at: (/* @__PURE__ */ new Date()).toISOString(),
+        input: JSON.stringify({
+          prompt: params.prompt,
+          tools: params.tools,
+          toolChoice: params.toolChoice,
+          maxOutputTokens: params.maxOutputTokens,
+          temperature: params.temperature,
+          topP: params.topP,
+          topK: params.topK,
+          presencePenalty: params.presencePenalty,
+          frequencyPenalty: params.frequencyPenalty,
+          seed: params.seed,
+          responseFormat: params.responseFormat
+        }),
+        provider_options: params.providerOptions ? JSON.stringify(params.providerOptions) : null
+      });
+      try {
+        const result = await doGenerate();
+        const durationMs = Date.now() - startTime;
+        await updateStepResult(stepId, {
+          duration_ms: durationMs,
+          output: JSON.stringify({
+            content: result.content,
+            finishReason: result.finishReason,
+            response: result.response
+          }),
+          usage: result.usage ? JSON.stringify(result.usage) : null,
+          error: null,
+          raw_request: result.request?.body ? JSON.stringify(result.request.body) : null,
+          raw_response: result.response?.body ? JSON.stringify(result.response.body) : null
+        });
+        return result;
+      } catch (error) {
+        const durationMs = Date.now() - startTime;
+        await updateStepResult(stepId, {
+          duration_ms: durationMs,
+          output: null,
+          usage: null,
+          error: error instanceof Error ? error.message : String(error),
+          raw_request: null,
+          raw_response: null
+        });
+        throw error;
+      }
+    },
+    wrapStream: async ({ doStream, params, model }) => {
+      const startTime = Date.now();
+      const stepId = generateId();
+      await ensureRunCreated();
+      const userRequestedRawChunks = params.includeRawChunks === true;
+      params.includeRawChunks = true;
+      await createStep({
+        id: stepId,
+        run_id: runId,
+        type: "stream",
+        model_id: model.modelId,
+        provider: model.provider,
+        started_at: (/* @__PURE__ */ new Date()).toISOString(),
+        input: JSON.stringify({
+          prompt: params.prompt,
+          tools: params.tools,
+          toolChoice: params.toolChoice,
+          maxOutputTokens: params.maxOutputTokens,
+          temperature: params.temperature,
+          topP: params.topP,
+          topK: params.topK,
+          presencePenalty: params.presencePenalty,
+          frequencyPenalty: params.frequencyPenalty,
+          seed: params.seed,
+          responseFormat: params.responseFormat
+        }),
+        provider_options: params.providerOptions ? JSON.stringify(params.providerOptions) : null
+      });
+      try {
+        const { stream, request, response, ...rest } = await doStream();
+        const collectedOutput = {
+          textParts: [],
+          reasoningParts: [],
+          toolCalls: []
+        };
+        const currentText = /* @__PURE__ */ new Map();
+        const currentReasoning = /* @__PURE__ */ new Map();
+        const fullStreamChunks = [];
+        const rawChunks = [];
+        activeSteps.set(stepId, {
+          startTime,
+          collectedOutput,
+          request,
+          fullStreamChunks,
+          rawChunks
+        });
+        const transformStream = new TransformStream({
+          transform(chunk, controller) {
+            if (chunk.type === "raw") {
+              rawChunks.push(chunk.rawValue);
+              if (userRequestedRawChunks) {
+                controller.enqueue(chunk);
+              }
+              return;
+            }
+            fullStreamChunks.push(chunk);
+            switch (chunk.type) {
+              case "text-start":
+                currentText.set(chunk.id, "");
+                break;
+              case "text-delta":
+                currentText.set(
+                  chunk.id,
+                  (currentText.get(chunk.id) ?? "") + chunk.delta
+                );
+                break;
+              case "text-end":
+                collectedOutput.textParts.push({
+                  id: chunk.id,
+                  text: currentText.get(chunk.id) ?? ""
+                });
+                break;
+              case "reasoning-start":
+                currentReasoning.set(chunk.id, "");
+                break;
+              case "reasoning-delta":
+                currentReasoning.set(
+                  chunk.id,
+                  (currentReasoning.get(chunk.id) ?? "") + chunk.delta
+                );
+                break;
+              case "reasoning-end":
+                collectedOutput.reasoningParts.push({
+                  id: chunk.id,
+                  text: currentReasoning.get(chunk.id) ?? ""
+                });
+                break;
+              case "tool-call":
+                collectedOutput.toolCalls.push(chunk);
+                break;
+              case "finish":
+                collectedOutput.finishReason = chunk.finishReason;
+                collectedOutput.usage = chunk.usage;
+                break;
+            }
+            controller.enqueue(chunk);
+          },
+          async flush() {
+            activeSteps.delete(stepId);
+            const durationMs = Date.now() - startTime;
+            await updateStepResult(stepId, {
+              duration_ms: durationMs,
+              output: JSON.stringify(collectedOutput),
+              usage: collectedOutput.usage ? JSON.stringify(collectedOutput.usage) : null,
+              error: null,
+              raw_request: request?.body ? JSON.stringify(request.body) : null,
+              raw_response: JSON.stringify(fullStreamChunks),
+              raw_chunks: JSON.stringify(rawChunks)
+            });
+          },
+          // @ts-expect-error - cancel is valid per WHATWG Streams spec but missing from TS types
+          async cancel() {
+            activeSteps.delete(stepId);
+            const durationMs = Date.now() - startTime;
+            await updateStepResult(stepId, {
+              duration_ms: durationMs,
+              output: JSON.stringify(collectedOutput),
+              usage: collectedOutput.usage ? JSON.stringify(collectedOutput.usage) : null,
+              error: "Request aborted",
+              raw_request: request?.body ? JSON.stringify(request.body) : null,
+              raw_response: JSON.stringify(fullStreamChunks),
+              raw_chunks: JSON.stringify(rawChunks)
+            });
+          }
+        });
+        return {
+          stream: stream.pipeThrough(transformStream),
+          request,
+          response,
+          ...rest
+        };
+      } catch (error) {
+        activeSteps.delete(stepId);
+        const durationMs = Date.now() - startTime;
+        await updateStepResult(stepId, {
+          duration_ms: durationMs,
+          output: null,
+          usage: null,
+          error: error instanceof Error ? error.message : String(error),
+          raw_request: null,
+          raw_response: null,
+          raw_chunks: null
+        });
+        throw error;
+      }
+    }
+  };
+};
+
+// src/logger.ts
+var generateId2 = () => crypto.randomUUID();
+var serialize = (value) => {
+  if (value === void 0 || value === null) return null;
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+async function createLogger(options = {}) {
+  if (process.env.NODE_ENV === "production") {
+    throw new Error(
+      "ailog should not be used in production. Remove createLogger calls from your production builds."
+    );
+  }
+  const runId = generateRunId();
+  await createRun(
+    runId,
+    options.functionId,
+    options.threadId,
+    options.metadata
+  );
+  return {
+    id: runId,
+    async step(input) {
+      const stepId = generateId2();
+      const startTime = Date.now();
+      await createStep({
+        id: stepId,
+        run_id: runId,
+        type: input.type ?? "generate",
+        model_id: input.modelId,
+        provider: input.provider ?? null,
+        started_at: (/* @__PURE__ */ new Date()).toISOString(),
+        input: serialize(input.input) ?? "null",
+        provider_options: serialize(input.providerOptions)
+      });
+      return {
+        id: stepId,
+        async end(result) {
+          const durationMs = Date.now() - startTime;
+          const errorMessage = result.error instanceof Error ? result.error.message : result.error !== void 0 && result.error !== null ? String(result.error) : null;
+          await updateStepResult(stepId, {
+            duration_ms: durationMs,
+            output: serialize(result.output),
+            usage: serialize(result.usage),
+            error: errorMessage,
+            raw_request: serialize(result.rawRequest),
+            raw_response: serialize(result.rawResponse),
+            raw_chunks: serialize(result.rawChunks)
+          });
+        }
+      };
+    }
+  };
+}
+export {
+  aiSdkMiddleware,
+  createLogger
+};