@rikalabs/logpoint 0.0.2

package/src/lib/injection-engine.ts

@@ -0,0 +1,329 @@
+import { Effect } from "effect";
+import { InjectionError, SecretVarBlocked } from "./errors.js";
+import { detectLanguage, type Language } from "./language.js";
+import { isSecretVariable } from "./secrets.js";
+import type { LogpointDef } from "./schema.js";
+import {
+  generateTemplate,
+  goImportPaths,
+  type GoTemplateRefs,
+} from "./templates.js";
+
+const markerStartPattern = /LOGPOINT_START\s*\[([^\]]+)\]/;
+const markerEndPattern = /LOGPOINT_END\s*\[([^\]]+)\]/;
+
+const parseMarkerId = (line: string): string | undefined => {
+  const matched = line.match(markerStartPattern) ?? line.match(markerEndPattern);
+  return matched?.[1];
+};
+
+const sanitizeGoAlias = (name: string): string => `__lp_${name.replace(/[^a-zA-Z0-9_]/g, "_")}`;
+
+type GoImportState = {
+  readonly lines: readonly string[];
+  readonly refs: GoTemplateRefs;
+};
+
+type ImportSpec = {
+  readonly alias?: string;
+  readonly path: string;
+  readonly raw: string;
+};
+
+const importLinePattern = /^\s*(?:(?<alias>[_A-Za-z][A-Za-z0-9_]*)\s+)?"(?<path>[^"]+)"/;
+
+const parseImportLine = (line: string): ImportSpec | undefined => {
+  const match = line.match(importLinePattern);
+  if (match === null) {
+    return undefined;
+  }
+  const alias = match.groups?.["alias"];
+  const path = match.groups?.["path"];
+  if (path === undefined) {
+    return undefined;
+  }
+  if (alias === undefined) {
+    return { path, raw: line.trim() };
+  }
+  return { alias, path, raw: line.trim() };
+};
+
+const parseSingleImport = (line: string): ImportSpec | undefined => {
+  const statement = line.trim();
+  if (!statement.startsWith("import ")) {
+    return undefined;
+  }
+  return parseImportLine(statement.slice("import ".length));
+};
+
+const defaultImportName = (path: string): string => {
+  const parts = path.split("/");
+  return parts[parts.length - 1] ?? path;
+};
+
+const importNameFromSpec = (spec: ImportSpec): string => {
+  if (spec.alias === undefined) {
+    return defaultImportName(spec.path);
+  }
+  if (spec.alias === "_" || spec.alias === ".") {
+    return defaultImportName(spec.path);
+  }
+  return spec.alias;
+};
+
+const ensureGoImports = (content: string): GoImportState => {
+  const required = {
+    bytes: goImportPaths.bytes,
+    json: goImportPaths.json,
+    http: goImportPaths.http,
+    time: goImportPaths.time,
+  } as const;
+
+  const lines = content.split("\n");
+  const importsByPath: Record<string, ImportSpec> = {};
+
+  let importStart = -1;
+  let importEnd = -1;
+  let isBlock = false;
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index]?.trim() ?? "";
+    if (line === "import (") {
+      importStart = index;
+      isBlock = true;
+      for (let inner = index + 1; inner < lines.length; inner += 1) {
+        const innerLine = lines[inner] ?? "";
+        if (innerLine.trim() === ")") {
+          importEnd = inner;
+          break;
+        }
+        const spec = parseImportLine(innerLine);
+        if (spec !== undefined) {
+          importsByPath[spec.path] = spec;
+        }
+      }
+      break;
+    }
+
+    if (line.startsWith("import ")) {
+      importStart = index;
+      importEnd = index;
+      isBlock = false;
+      const spec = parseSingleImport(line);
+      if (spec !== undefined) {
+        importsByPath[spec.path] = spec;
+      }
+      break;
+    }
+  }
+
+  const refs: GoTemplateRefs = {
+    bytesRef: importNameFromSpec(importsByPath[required.bytes] ?? { path: required.bytes, raw: "" }),
+    jsonRef: importNameFromSpec(importsByPath[required.json] ?? { path: required.json, raw: "" }),
+    httpRef: importNameFromSpec(importsByPath[required.http] ?? { path: required.http, raw: "" }),
+    timeRef: importNameFromSpec(importsByPath[required.time] ?? { path: required.time, raw: "" }),
+  };
+
+  const missing: Array<{ readonly path: string; readonly alias: string; readonly key: keyof GoTemplateRefs }> = [];
+
+  if (importsByPath[required.bytes] === undefined) {
+    const alias = sanitizeGoAlias("bytes");
+    refs.bytesRef = alias;
+    missing.push({ path: required.bytes, alias, key: "bytesRef" });
+  }
+  if (importsByPath[required.json] === undefined) {
+    const alias = sanitizeGoAlias("json");
+    refs.jsonRef = alias;
+    missing.push({ path: required.json, alias, key: "jsonRef" });
+  }
+  if (importsByPath[required.http] === undefined) {
+    const alias = sanitizeGoAlias("http");
+    refs.httpRef = alias;
+    missing.push({ path: required.http, alias, key: "httpRef" });
+  }
+  if (importsByPath[required.time] === undefined) {
+    const alias = sanitizeGoAlias("time");
+    refs.timeRef = alias;
+    missing.push({ path: required.time, alias, key: "timeRef" });
+  }
+
+  if (missing.length === 0) {
+    return { lines, refs };
+  }
+
+  const importLines = missing.map((item) => `\t${item.alias} "${item.path}" // LOGPOINT_IMPORT`);
+
+  if (importStart >= 0 && importEnd >= importStart && isBlock) {
+    const updated = [...lines];
+    updated.splice(importEnd, 0, ...importLines);
+    return { lines: updated, refs };
+  }
+
+  if (importStart >= 0 && importEnd === importStart && !isBlock) {
+    const single = lines[importStart] ?? "";
+    const spec = parseSingleImport(single.trim());
+    const existing = spec === undefined ? [] : [`\t${spec.raw}`];
+    const block = ["import (", ...existing, ...importLines, ")"];
+    const updated = [...lines];
+    updated.splice(importStart, 1, ...block);
+    return { lines: updated, refs };
+  }
+
+  const packageIndex = lines.findIndex((line) => line.trim().startsWith("package "));
+  const updated = [...lines];
+  const insertionIndex = packageIndex >= 0 ? packageIndex + 1 : 0;
+  updated.splice(insertionIndex, 0, "", "import (", ...importLines, ")", "");
+  return { lines: updated, refs };
+};
+
+export type InjectContentResult = {
+  readonly content: string;
+  readonly inserted: number;
+  readonly blocked: readonly SecretVarBlocked[];
+};
+
+const hasLogpointId = (content: string, id: string): boolean =>
+  content.includes(`LOGPOINT_START [${id}]`) || content.includes(`LOGPOINT_END [${id}]`);
+
+const sortDescendingByLine = (defs: readonly LogpointDef[]): readonly LogpointDef[] =>
+  [...defs].sort((a, b) => b.line - a.line);
+
+const safeCaptureVars = (
+  capture: readonly string[],
+  logpointId: string,
+): {
+  readonly safe: readonly string[];
+  readonly blocked: readonly SecretVarBlocked[];
+} => {
+  const safe: string[] = [];
+  const blocked: SecretVarBlocked[] = [];
+
+  for (const variable of capture) {
+    if (isSecretVariable(variable)) {
+      blocked.push(new SecretVarBlocked({ logpointId, variable }));
+      continue;
+    }
+    safe.push(variable);
+  }
+
+  return { safe, blocked };
+};
+
+export const injectContent = (
+  content: string,
+  defs: readonly LogpointDef[],
+  filePath: string,
+  port: number,
+  explicitLanguage?: Language,
+): Effect.Effect<InjectContentResult, InjectionError, never> =>
+  Effect.gen(function* () {
+    const language = explicitLanguage ?? detectLanguage(filePath);
+    let lines = content.split("\n");
+    let goRefs: GoTemplateRefs | undefined;
+    const blocked: SecretVarBlocked[] = [];
+    let inserted = 0;
+
+    if (language === "go") {
+      const goImportState = ensureGoImports(lines.join("\n"));
+      lines = [...goImportState.lines];
+      goRefs = goImportState.refs;
+    }
+
+    for (const def of sortDescendingByLine(defs)) {
+      if (hasLogpointId(lines.join("\n"), def.id)) {
+        continue;
+      }
+
+      if (def.line < 1 || def.line > lines.length + 1) {
+        return yield* Effect.fail(
+          new InjectionError({
+            logpointId: def.id,
+            file: filePath,
+            line: def.line,
+            reason: `Line ${def.line} out of range (1-${lines.length + 1})`,
+          }),
+        );
+      }
+
+      const capture = safeCaptureVars(def.capture, def.id);
+      blocked.push(...capture.blocked);
+
+      const template = generateTemplate(
+        {
+          ...def,
+          capture: capture.safe,
+          port,
+          ...(goRefs === undefined ? {} : { goRefs }),
+        },
+        language,
+      );
+
+      goRefs = template.goRefs ?? goRefs;
+
+      lines.splice(def.line - 1, 0, ...template.lines);
+      inserted += 1;
+    }
+
+    return {
+      content: lines.join("\n"),
+      inserted,
+      blocked,
+    };
+  });
+
+export type CleanupContentResult = {
+  readonly cleaned: string;
+  readonly removed: number;
+};
+
+export const cleanupContent = (
+  content: string,
+  ids?: readonly string[],
+): CleanupContentResult => {
+  const lines = content.split("\n");
+  const filteredIds = ids === undefined ? undefined : new Set(ids);
+  const out: string[] = [];
+
+  let inside = false;
+  let activeId: string | undefined;
+  let removed = 0;
+
+  for (const line of lines) {
+    if (inside) {
+      if (line.includes("LOGPOINT_END")) {
+        const endId = parseMarkerId(line);
+        if (activeId === undefined || endId === undefined || endId === activeId) {
+          inside = false;
+          activeId = undefined;
+          continue;
+        }
+      }
+      continue;
+    }
+
+    if (line.includes("LOGPOINT_START")) {
+      const id = parseMarkerId(line);
+      if (id === undefined) {
+        continue;
+      }
+
+      if (filteredIds === undefined || filteredIds.has(id)) {
+        inside = true;
+        activeId = id;
+        removed += 1;
+        continue;
+      }
+    }
+
+    if (filteredIds === undefined && line.includes("LOGPOINT_IMPORT")) {
+      continue;
+    }
+
+    out.push(line);
+  }
+
+  return { cleaned: out.join("\n"), removed };
+};
+
+export const countMarkers = (content: string): number =>
+  content.split("\n").reduce((count, line) => count + (line.includes("LOGPOINT_START") ? 1 : 0), 0);

package/src/lib/jsonl.ts

@@ -0,0 +1,40 @@
+import { appendFile, readFile } from "node:fs/promises";
+import { Effect } from "effect";
+import { FileReadError, FileWriteError, ParseError } from "./errors.js";
+
+export const appendJsonLine = (
+  path: string,
+  payload: unknown,
+): Effect.Effect<void, FileWriteError | ParseError, never> =>
+  Effect.try({
+    try: () => JSON.stringify(payload),
+    catch: (cause) => new ParseError({ input: String(payload), cause }),
+  }).pipe(
+    Effect.flatMap((line) =>
+      Effect.tryPromise({
+        try: async () => {
+          await appendFile(path, `${line}\n`, "utf8");
+        },
+        catch: (cause) => new FileWriteError({ path, cause }),
+      }),
+    ),
+  );
+
+export const readJsonLines = (path: string): Effect.Effect<readonly unknown[], FileReadError | ParseError, never> =>
+  Effect.tryPromise({
+    try: () => readFile(path, "utf8"),
+    catch: (cause) => new FileReadError({ path, cause }),
+  }).pipe(
+    Effect.flatMap((content) => {
+      const lines = content
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+      return Effect.forEach(lines, (line) =>
+        Effect.try({
+          try: () => JSON.parse(line) as unknown,
+          catch: (cause) => new ParseError({ input: line, cause }),
+        }),
+      );
+    }),
+  );

package/src/lib/language.ts

@@ -0,0 +1,49 @@
+import { extname } from "node:path";
+
+export const SupportedLanguages = [
+  "javascript",
+  "typescript",
+  "python",
+  "go",
+  "ruby",
+  "shell",
+  "java",
+  "csharp",
+  "php",
+  "rust",
+  "kotlin",
+] as const;
+
+export type Language = (typeof SupportedLanguages)[number];
+
+const extensionMap: Readonly<Record<string, Language>> = {
+  ".js": "javascript",
+  ".cjs": "javascript",
+  ".mjs": "javascript",
+  ".jsx": "javascript",
+  ".ts": "typescript",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".tsx": "typescript",
+  ".py": "python",
+  ".go": "go",
+  ".rb": "ruby",
+  ".sh": "shell",
+  ".bash": "shell",
+  ".zsh": "shell",
+  ".ksh": "shell",
+  ".java": "java",
+  ".cs": "csharp",
+  ".php": "php",
+  ".rs": "rust",
+  ".kt": "kotlin",
+  ".kts": "kotlin",
+};
+
+export const isLanguage = (value: string): value is Language =>
+  (SupportedLanguages as readonly string[]).includes(value);
+
+export const detectLanguage = (filePath: string): Language => {
+  const extension = extname(filePath).toLowerCase();
+  return extensionMap[extension] ?? "javascript";
+};

package/src/lib/render.ts

@@ -0,0 +1,173 @@
+import type { Snapshot } from "./schema.js";
+
+export type SnapshotGroups = Readonly<Record<string, readonly Snapshot[]>>;
+
+export type Anomaly = {
+  readonly id: string;
+  readonly variable: string;
+  readonly message: string;
+};
+
+const stableStringify = (value: unknown): string => {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+
+const formatCell = (value: unknown): string => {
+  const rendered = stableStringify(value);
+  if (rendered.length <= 40) {
+    return rendered;
+  }
+  return `${rendered.slice(0, 37)}...`;
+};
+
+const collectVariables = (snapshots: readonly Snapshot[]): readonly string[] => {
+  const keys = new Set<string>();
+  for (const snapshot of snapshots) {
+    for (const key of Object.keys(snapshot.vars)) {
+      keys.add(key);
+    }
+  }
+  return [...keys].sort();
+};
+
+export const groupSnapshots = (snapshots: readonly Snapshot[]): SnapshotGroups => {
+  const grouped: Record<string, Snapshot[]> = {};
+  for (const snapshot of snapshots) {
+    const current = grouped[snapshot.id] ?? [];
+    current.push(snapshot);
+    grouped[snapshot.id] = current;
+  }
+
+  const normalized: Record<string, readonly Snapshot[]> = {};
+  for (const [id, entries] of Object.entries(grouped)) {
+    normalized[id] = [...entries].sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  }
+  return normalized;
+};
+
+const hasStableOtherVariables = (
+  snapshots: readonly Snapshot[],
+  targetVariable: string,
+  variables: readonly string[],
+): boolean => {
+  for (const variable of variables) {
+    if (variable === targetVariable) {
+      continue;
+    }
+
+    const values = snapshots.map((snapshot) => stableStringify(snapshot.vars[variable]));
+    if (new Set(values).size > 1) {
+      return false;
+    }
+  }
+
+  return true;
+};
+
+export const detectAnomalies = (groups: SnapshotGroups): readonly Anomaly[] => {
+  const anomalies: Anomaly[] = [];
+
+  for (const [id, snapshots] of Object.entries(groups)) {
+    const variables = collectVariables(snapshots);
+
+    for (const variable of variables) {
+      const values = snapshots.map((snapshot) => snapshot.vars[variable]);
+      const serialized = values.map((value) => stableStringify(value));
+      const uniqueSerialized = new Set(serialized);
+
+      if (values.some((value) => value === null || value === undefined)) {
+        anomalies.push({
+          id,
+          variable,
+          message: `Value is null or undefined in at least one hit`,
+        });
+      }
+
+      const typeSet = new Set(values.map((value) => typeof value));
+      if (typeSet.size > 1) {
+        anomalies.push({
+          id,
+          variable,
+          message: `Type changed across hits (${[...typeSet].join(" -> ")})`,
+        });
+      }
+
+      const numericValues = values.filter((value): value is number => typeof value === "number");
+      if (numericValues.length >= 2) {
+        const minValue = Math.min(...numericValues);
+        const maxValue = Math.max(...numericValues);
+        if (minValue > 0 && maxValue / minValue >= 2) {
+          anomalies.push({
+            id,
+            variable,
+            message: `Value grew significantly (${minValue} -> ${maxValue})`,
+          });
+        }
+      }
+
+      if (uniqueSerialized.size > 1 && hasStableOtherVariables(snapshots, variable, variables)) {
+        const first = serialized[0] ?? "unknown";
+        const second = serialized.find((value) => value !== first) ?? "unknown";
+        anomalies.push({
+          id,
+          variable,
+          message: `Value changed while other variables stayed constant (${first} -> ${second})`,
+        });
+      }
+    }
+  }
+
+  return anomalies;
+};
+
+export const renderMarkdown = (
+  groups: SnapshotGroups,
+  anomalies: readonly Anomaly[],
+): string => {
+  const sections: string[] = ["## Logpoint Results", ""];
+
+  const ids = Object.keys(groups).sort();
+  for (const id of ids) {
+    const snapshots = groups[id] ?? [];
+    if (snapshots.length === 0) {
+      continue;
+    }
+
+    const first = snapshots[0];
+    const variables = collectVariables(snapshots);
+
+    sections.push(`### ${id} - ${first?.label ?? "unknown"} (${snapshots.length} hits)`);
+
+    const header = ["Hit", ...variables];
+    const separator = header.map(() => "---");
+    sections.push(`| ${header.join(" | ")} |`);
+    sections.push(`| ${separator.join(" | ")} |`);
+
+    snapshots.forEach((snapshot, index) => {
+      const cells = [String(index + 1), ...variables.map((key) => formatCell(snapshot.vars[key]))];
+      sections.push(`| ${cells.join(" | ")} |`);
+    });
+
+    sections.push("");
+  }
+
+  sections.push("## Anomalies");
+  if (anomalies.length === 0) {
+    sections.push("- None detected");
+  } else {
+    for (const anomaly of anomalies) {
+      sections.push(`- **${anomaly.id}.${anomaly.variable}**: ${anomaly.message}`);
+    }
+  }
+
+  return sections.join("\n");
+};
+
+export const renderJson = (
+  groups: SnapshotGroups,
+  anomalies: readonly Anomaly[],
+): string => JSON.stringify({ groups, anomalies }, null, 2);