@ailog/cli 0.2.3 → 0.2.6

package/dist/index.js

@@ -0,0 +1,609 @@
+// src/db.ts
+import path from "path";
+import fs from "fs";
+var DB_DIR = path.join(process.cwd(), ".ailog");
+var INDEX_PATH = path.join(DB_DIR, "index.json");
+var RUNS_DIR = path.join(DB_DIR, "runs");
+var BLOBS_DIR = path.join(DB_DIR, "blobs");
+var AILOG_PORT = process.env.AILOG_PORT ? parseInt(process.env.AILOG_PORT) : 4985;
+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(),
+        dbPath: INDEX_PATH,
+        runId: runId ?? null
+      })
+    });
+  } catch {
+  }
+};
+var generateRunId = () => {
+  const now = /* @__PURE__ */ new Date();
+  const timestamp = now.toISOString().replace(/[-:T.Z]/g, "").slice(0, 17);
+  const uniqueId = crypto.randomUUID().slice(0, 8);
+  return `${timestamp}-${uniqueId}`;
+};
+var EMPTY_INDEX = () => ({
+  version: 1,
+  runs: [],
+  threads: []
+});
+var normalizeIndex = (raw) => ({
+  version: 1,
+  runs: raw.runs ?? [],
+  threads: raw.threads ?? []
+});
+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 });
+  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 indexCache = null;
+var runCache = /* @__PURE__ */ new Map();
+var remoteDbDir = null;
+var currentDbDir = () => remoteDbDir ?? DB_DIR;
+var currentIndexPath = () => path.join(currentDbDir(), "index.json");
+var currentRunPath = (runId) => path.join(currentDbDir(), "runs", `${runId}.json`);
+var loadIndex = () => {
+  if (indexCache) return indexCache;
+  indexCache = normalizeIndex(
+    safeReadJson(currentIndexPath(), EMPTY_INDEX())
+  );
+  return indexCache;
+};
+var persistIndex = () => {
+  if (!indexCache) return;
+  atomicWrite(INDEX_PATH, JSON.stringify(indexCache, null, 2));
+};
+var loadRunFile = (runId) => {
+  const cached = runCache.get(runId);
+  if (cached) return cached;
+  const file = safeReadJson(currentRunPath(runId), 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,
+    metadata: file.run.metadata,
+    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) => {
+  const index = loadIndex();
+  const existing = index.threads.find((t) => t.id === threadId);
+  if (existing) {
+    if (new Date(runStartedAt) > new Date(existing.updated_at)) {
+      existing.updated_at = runStartedAt;
+    }
+    existing.run_count += 1;
+  } else {
+    index.threads.push({
+      id: threadId,
+      created_at: runStartedAt,
+      updated_at: runStartedAt,
+      run_count: 1
+    });
+  }
+};
+var upsertSummary = (file) => {
+  const index = loadIndex();
+  const summary = recomputeSummary(file);
+  const i = index.runs.findIndex((r) => r.id === summary.id);
+  if (i === -1) {
+    index.runs.push(summary);
+  } else {
+    index.runs[i] = summary;
+  }
+};
+var createRun = async (id, functionId, metadata, threadId) => {
+  ensureLayout();
+  const existing = loadRunFile(id);
+  if (existing) return existing.run;
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const run = {
+    id,
+    started_at: startedAt,
+    function_id: functionId ?? null,
+    metadata: metadata && typeof metadata === "object" ? JSON.stringify(metadata) : null,
+    thread_id: threadId ?? null
+  };
+  const file = { version: 1, run, steps: [] };
+  persistRunFile(id, file);
+  upsertSummary(file);
+  if (threadId) upsertThread(threadId, startedAt);
+  persistIndex();
+  notifyServer("run", id);
+  return run;
+};
+var createStep = async (step) => {
+  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);
+  persistIndex();
+  notifyServer("step", file.run.id);
+  return stepNumber;
+};
+var updateStepResult = async (stepId, result) => {
+  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 summary of loadIndex().runs) {
+      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 || !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);
+  persistIndex();
+  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 = options.runId ?? generateRunId();
+  let runCreated = false;
+  const ensureRunCreated = async () => {
+    if (!runCreated) {
+      await createRun(
+        runId,
+        options.functionId,
+        options.metadata,
+        options.threadId
+      );
+      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 = options.runId ?? generateRunId();
+  await createRun(
+    runId,
+    options.functionId,
+    options.metadata,
+    options.threadId
+  );
+  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,
+  generateRunId
+};