@scrylog/cli 0.1.0

package/src/daemon/collectors/codex/transcript.ts

@@ -0,0 +1,299 @@
+import type { SessionState } from "../../../shared/types";
+import type { CodexJsonlEntry } from "./jsonl";
+import { isResponseItem, getResponseItemText, getResponseItemRole, getFunctionCallName, isEventMsg } from "./jsonl";
+
+export interface CodexTranscriptMeta {
+  sessionId: string;
+  model?: string;
+  forkedFromId?: string;
+  parentSessionId?: string;
+  agentNickname?: string;
+  agentRole?: string;
+  totalInputTokens?: number;
+  totalOutputTokens?: number;
+  totalCachedInputTokens?: number;
+}
+
+export interface CodexSpawnedSubagent {
+  agentId: string;
+  agentType?: string;
+  nickname?: string;
+}
+
+export function extractMeta(entries: CodexJsonlEntry[]): CodexTranscriptMeta {
+  const meta: CodexTranscriptMeta = { sessionId: "" };
+  let lastTurnModel: string | undefined;
+
+  for (const entry of entries) {
+    switch (entry.type) {
+      case "session_meta": {
+        const payload = entry.payload ?? {};
+        const sid = (payload.session_id as string | undefined)
+          ?? (payload.sessionId as string | undefined)
+          ?? (payload.id as string | undefined)
+          ?? entry.session_id
+          ?? entry.sessionId
+          ?? entry.id;
+        if (sid && typeof sid === "string") {
+          meta.sessionId = sid;
+        }
+        const forkedFrom = (payload.forked_from_id as string | undefined)
+          ?? (payload.forkedFromId as string | undefined)
+          ?? (payload.parent_session_id as string | undefined)
+          ?? (payload.parentSessionId as string | undefined);
+        if (forkedFrom && typeof forkedFrom === "string") {
+          meta.forkedFromId = forkedFrom;
+        }
+
+        const source = payload.source as Record<string, unknown> | undefined;
+        const subagent = source?.subagent as Record<string, unknown> | undefined;
+        const threadSpawn = subagent?.thread_spawn as Record<string, unknown> | undefined;
+        const parentThreadId = threadSpawn?.parent_thread_id;
+        if (typeof parentThreadId === "string" && parentThreadId.length > 0) {
+          meta.parentSessionId = `codex:${parentThreadId}`;
+        }
+
+        const agentNickname = payload.agent_nickname ?? threadSpawn?.agent_nickname;
+        if (typeof agentNickname === "string" && agentNickname.length > 0) {
+          meta.agentNickname = agentNickname;
+        }
+        const agentRole = payload.agent_role ?? threadSpawn?.agent_role;
+        if (typeof agentRole === "string" && agentRole.length > 0) {
+          meta.agentRole = agentRole;
+        }
+        break;
+      }
+      case "turn_context": {
+        const payload = entry.payload ?? {};
+        const model = (payload.model as string | undefined)
+          ?? ((payload.info as Record<string, unknown> | undefined)?.model as string | undefined);
+        if (model && typeof model === "string") {
+          lastTurnModel = model;
+          meta.model = model;
+        }
+        break;
+      }
+      case "event_msg": {
+        const payload = entry.payload ?? {};
+        if (payload.type !== "token_count") break;
+        const info = payload.info as Record<string, unknown> | undefined;
+        if (!info) break;
+
+        // Model resolution
+        const model = (info.model as string | undefined)
+          ?? (info.model_name as string | undefined)
+          ?? (payload.model as string | undefined)
+          ?? entry.model
+          ?? lastTurnModel;
+        if (model && typeof model === "string") {
+          meta.model = model;
+        }
+
+        // Token usage
+        const totalUsage = info.total_token_usage as Record<string, number> | undefined;
+        if (totalUsage) {
+          meta.totalInputTokens = totalUsage.input_tokens;
+          meta.totalOutputTokens = totalUsage.output_tokens;
+          const cached = totalUsage.cached_input_tokens ?? totalUsage.cache_read_input_tokens ?? 0;
+          meta.totalCachedInputTokens = Math.min(cached, totalUsage.input_tokens ?? 0);
+        }
+        break;
+      }
+    }
+  }
+
+  return meta;
+}
+
+function normalizeText(text: string): string {
+  return text.trim();
+}
+
+function isQuestionText(text: string): boolean {
+  const trimmed = normalizeText(text);
+  return /^(would you|do you|can you|should i|please confirm|shall i|want me to|implement this plan|implemente this plan|apply this plan|continue with this plan|proceed with this plan)\b/i.test(trimmed)
+    || /^(quieres que|debo|puedo|confirmas|por favor confirma|contin[uú]o|procedo)\b/i.test(trimmed)
+    || /^¿?(qu[eé]|cu[aá]l|cu[aá]les|c[oó]mo|d[oó]nde|cu[aá]ndo|por qu[eé])(?:\s|\?|$)/i.test(trimmed);
+}
+
+function parseJsonObject(value: unknown): Record<string, unknown> | undefined {
+  if (typeof value !== "string") return undefined;
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    return typeof parsed === "object" && parsed !== null ? parsed as Record<string, unknown> : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function readCompletedSubagentIds(entries: CodexJsonlEntry[]): Set<string> {
+  const completed = new Set<string>();
+  for (const entry of entries) {
+    if (!isResponseItem(entry)) continue;
+    const text = getResponseItemText(entry);
+    if (text) {
+      const match = /<subagent_notification>\s*([\s\S]*?)\s*<\/subagent_notification>/i.exec(text);
+      const payload = match ? parseJsonObject(match[1]) : undefined;
+      const agentPath = payload?.agent_path;
+      if (typeof agentPath === "string") completed.add(agentPath);
+    }
+
+    if (entry.payload.type !== "function_call_output") continue;
+    const output = parseJsonObject(entry.payload.output);
+    const status = output?.status;
+    if (typeof status !== "object" || status === null) continue;
+    for (const [agentId, value] of Object.entries(status as Record<string, unknown>)) {
+      if (typeof value === "object" && value !== null && "completed" in value) {
+        completed.add(agentId);
+      }
+    }
+  }
+  return completed;
+}
+
+export function extractActiveSpawnedSubagents(entries: CodexJsonlEntry[]): CodexSpawnedSubagent[] {
+  const completed = readCompletedSubagentIds(entries);
+  const callTypes = new Map<string, string | undefined>();
+  const spawned = new Map<string, CodexSpawnedSubagent>();
+
+  for (const entry of entries) {
+    if (!isResponseItem(entry)) continue;
+
+    if (entry.payload.type === "function_call" && entry.payload.name === "spawn_agent") {
+      const callId = entry.payload.call_id;
+      const args = parseJsonObject(entry.payload.arguments);
+      const agentType = args?.agent_type;
+      if (typeof callId === "string") {
+        callTypes.set(callId, typeof agentType === "string" ? agentType : undefined);
+      }
+      continue;
+    }
+
+    if (entry.payload.type !== "function_call_output") continue;
+    const callId = entry.payload.call_id;
+    if (typeof callId !== "string" || !callTypes.has(callId)) continue;
+    const output = parseJsonObject(entry.payload.output);
+    const agentId = output?.agent_id;
+    if (typeof agentId !== "string" || completed.has(agentId)) continue;
+    const nickname = output?.nickname;
+    const agentType = callTypes.get(callId);
+    spawned.set(agentId, {
+      agentId,
+      ...(agentType ? { agentType } : {}),
+      ...(typeof nickname === "string" ? { nickname } : {}),
+    });
+  }
+
+  return [...spawned.values()];
+}
+
+export function isResponseItemAskingQuestion(entry: CodexJsonlEntry): boolean {
+  if (!isResponseItem(entry)) return false;
+  if (getResponseItemRole(entry) !== "assistant") return false;
+  const text = getResponseItemText(entry);
+  if (!text) return false;
+  return isQuestionText(text);
+}
+
+export function isRequestUserInputCall(entry: CodexJsonlEntry): boolean {
+  if (!isResponseItem(entry)) return false;
+  return getFunctionCallName(entry) === "request_user_input";
+}
+
+function isAsyncProcessRunningOutput(entry: CodexJsonlEntry): boolean {
+  if (!isResponseItem(entry)) return false;
+  if (entry.payload.type !== "function_call_output") return false;
+  const output = entry.payload.output;
+  return typeof output === "string" && /Process running with session ID\s+\d+/i.test(output);
+}
+
+export function findLastMeaningfulResponseIndex(entries: CodexJsonlEntry[]): number {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i]!;
+    if (!isResponseItem(entry)) continue;
+    // Skip turn_aborted placeholder messages — these are system-generated
+    // and don't represent actual user responses.
+    const role = getResponseItemRole(entry);
+    const text = getResponseItemText(entry);
+    if (role === "user" && text?.includes("<turn_aborted>")) continue;
+    return i;
+  }
+  return -1;
+}
+
+export function extractState(entries: CodexJsonlEntry[]): SessionState {
+  if (entries.length === 0) return "idle";
+
+  const hasTaskStarted = entries.some((e) => isEventMsg(e) && e.payload.type === "task_started");
+  const hasTaskComplete = entries.some((e) => isEventMsg(e) && e.payload.type === "task_complete");
+
+  const lastIdx = findLastMeaningfulResponseIndex(entries);
+  if (lastIdx < 0) {
+    if (hasTaskStarted && !hasTaskComplete) return "working";
+    return "idle";
+  }
+
+  const lastEntry = entries[lastIdx]! as CodexJsonlEntry & { payload: Record<string, unknown> };
+
+  if (isRequestUserInputCall(lastEntry)) return "waiting-input";
+
+  const role = getResponseItemRole(lastEntry as Parameters<typeof getResponseItemRole>[0]);
+  const text = getResponseItemText(lastEntry as Parameters<typeof getResponseItemText>[0]);
+  const payloadType = lastEntry.payload?.type;
+
+  if (role === "assistant" && text && isQuestionText(text)) return "waiting-input";
+
+  if (role === "assistant" && text) return "idle";
+
+  if (payloadType === "function_call") return "working";
+  if (isAsyncProcessRunningOutput(lastEntry)) return "working";
+
+  if (role === "user") return "working";
+
+  const afterEntries = entries.slice(lastIdx + 1);
+  const hasTaskStartedAfter = afterEntries.some((e) => isEventMsg(e) && e.payload.type === "task_started");
+  const hasTaskCompleteAfter = afterEntries.some((e) => isEventMsg(e) && e.payload.type === "task_complete");
+  if (hasTaskStartedAfter && !hasTaskCompleteAfter) return "working";
+  if (hasTaskStarted && !hasTaskComplete) return "working";
+
+  return "idle";
+}
+
+export function extractSummary(entries: CodexJsonlEntry[]): string | undefined {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i]!;
+    if (!isResponseItem(entry)) continue;
+    if (getResponseItemRole(entry) !== "assistant") continue;
+
+    const funcName = getFunctionCallName(entry);
+    if (funcName) {
+      const args = entry.payload?.arguments;
+      if (funcName === "request_user_input" && typeof args === "object" && args !== null) {
+        const question = (args as Record<string, unknown>).question;
+        if (typeof question === "string") {
+          const first = question.split("\n")[0] ?? "";
+          if (first.length > 0) return first.slice(0, 120);
+        }
+      }
+      return `Using ${funcName}`;
+    }
+
+    const text = getResponseItemText(entry);
+    if (text) {
+      const first = normalizeText(text).split("\n")[0] ?? "";
+      if (first.length > 0) return first.slice(0, 120);
+    }
+  }
+
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i]!;
+    if (!isEventMsg(entry)) continue;
+    if (entry.payload.type !== "agent_message") continue;
+    const msg = entry.payload.message;
+    if (typeof msg === "string" && msg.trim().length > 0) {
+      return msg.trim().split("\n")[0]!.slice(0, 120);
+    }
+  }
+
+  return undefined;
+}

package/src/daemon/collectors/git.ts

@@ -0,0 +1,295 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import type { ProjectInfo } from "../../shared/types";
+import { maybeRunCommandInDirectory, safeBasename } from "../../shared/utils";
+import type { ScrylogConfig } from "../../shared/config";
+import type { DaemonStore } from "../store";
+import type { Collector } from "../scheduler";
+import { IS_WSL } from "../../shared/platform";
+
+import type { Logger } from "../../shared/logger";
+import { NOOP_LOGGER } from "../../shared/logger";
+
+export type { ProjectInfo };
+
+interface GitCommandContext {
+  cwd: string;
+  gitDir?: string;
+  workTree?: string;
+}
+
+export function resolveProjectInfo(currentPath: string, cache = new Map<string, ProjectInfo>(), timeoutMs?: number): ProjectInfo {
+  const normalizedPath = normalizePathForLookup(currentPath);
+  const cached = lookupCachedProject(normalizedPath, cache);
+  if (cached) {
+    return cached;
+  }
+
+  const visited: string[] = [];
+  const searchStart = resolveSearchStart(normalizedPath);
+  const gitMarkerDirectory = findGitMarkerDirectory(searchStart, visited, cache);
+
+  let project = buildFallbackProjectInfo(normalizedPath);
+  if (gitMarkerDirectory) {
+    project = resolveGitProjectInfo(gitMarkerDirectory, normalizedPath, timeoutMs) ?? buildFallbackProjectInfo(normalizedPath, gitMarkerDirectory);
+  }
+
+  const cacheKeys = project.isGitRepository
+    ? [...visited, normalizedPath, project.gitRootPath].filter((value): value is string => Boolean(value))
+    : [normalizedPath];
+  for (const cacheKey of cacheKeys) {
+    cache.set(cacheKey, project);
+  }
+
+  return project;
+}
+
+export function buildCompactProjectLabel(project: Pick<ProjectInfo, "displayName" | "isGitRepository" | "branch" | "isWorktree">): string {
+  if (!project.isGitRepository) {
+    return project.displayName;
+  }
+
+  const branch = project.branch || "detached";
+  const repoKind = project.isWorktree ? "wt" : "git";
+  return `${project.displayName}@${branch} [${repoKind}]`;
+}
+
+export function parseRemoteProjectName(remoteUrl: string): string {
+  const trimmed = remoteUrl.trim().replace(/[\\/]+$/, "");
+  if (!trimmed) {
+    return "";
+  }
+
+  const normalized = trimmed.replace(/[:](?=[^/]+\/)/, "/");
+  const lastSegment = normalized.split("/").filter(Boolean).pop() ?? "";
+  return lastSegment.replace(/\.git$/i, "");
+}
+
+export function isGitWorktree(gitDir: string, gitCommonDir: string, cwd: string): boolean {
+  return resolve(cwd, gitDir) !== resolve(cwd, gitCommonDir);
+}
+
+/**
+ * Thin collector wrapper around the existing git resolution logic.
+ * Exposes a shared cache for other collectors.
+ */
+export class GitCollector implements Collector {
+  name = "git";
+  readonly cache = new Map<string, ProjectInfo>();
+  private logger: Logger = NOOP_LOGGER;
+  private timeoutMs: number | undefined;
+  private maxEntries = 1_000;
+
+  start(_store: DaemonStore, config: ScrylogConfig, logger: Logger): void {
+    this.logger = logger;
+    this.timeoutMs = config.daemon.commandTimeoutMs;
+    this.maxEntries = config.retention.cacheMaxEntries;
+    logger.info("git", "Collector started", { event: "collector.started", collector: this.name, mode: "on-demand" });
+  }
+
+  stop(): void {
+    // Nothing to stop
+    this.logger.info("git", "Collector stopped", { event: "collector.stopped", collector: this.name });
+  }
+
+  resolve(path: string): ProjectInfo {
+    const cached = this.cache.has(path);
+    if (!cached) {
+      this.logger.debug("git", "Cache miss — resolving git info", { event: "cache.miss", path });
+    }
+    const result = resolveProjectInfo(path, this.cache, this.timeoutMs);
+    trimMap(this.cache, this.maxEntries);
+    if (!cached && result.isGitRepository) {
+      this.logger.debug("git", "Resolved git project", {
+        event: "project.resolved",
+        path,
+        displayName: result.displayName,
+        branch: result.branch,
+        isWorktree: result.isWorktree,
+        gitRootPath: result.gitRootPath,
+      });
+    }
+    return result;
+  }
+}
+
+function resolveGitProjectInfo(gitMarkerDirectory: string, currentPath: string, timeoutMs?: number): ProjectInfo | null {
+  const commandContext = resolveGitCommandContext(gitMarkerDirectory);
+  const topLevel = runGit(commandContext, ["rev-parse", "--show-toplevel"], timeoutMs);
+  if (!topLevel.ok) {
+    return null;
+  }
+
+  const gitDir = runGit(commandContext, ["rev-parse", "--git-dir"], timeoutMs);
+  const gitCommonDir = runGit(commandContext, ["rev-parse", "--git-common-dir"], timeoutMs);
+  const remoteNamesResult = runGit(commandContext, ["remote"], timeoutMs);
+
+  const gitRootPath = normalizeWslWindowsPath(topLevel.output.trim());
+  const gitDirPath = gitDir.ok ? normalizeWslWindowsPath(gitDir.output.trim()) : undefined;
+  const gitCommonDirPath = gitCommonDir.ok ? normalizeWslWindowsPath(gitCommonDir.output.trim()) : undefined;
+  const repositoryIdentityPath = gitCommonDir.ok
+    ? resolveRepositoryIdentityPath(gitMarkerDirectory, gitCommonDirPath ?? "", gitRootPath)
+    : gitRootPath;
+  const branch = resolveBranchName(commandContext, timeoutMs);
+  const remoteNames = remoteNamesResult.ok
+    ? remoteNamesResult.output.split(/\r?\n/).map((name) => name.trim()).filter(Boolean)
+    : [];
+  const preferredRemote = remoteNames.includes("origin") ? "origin" : remoteNames[0];
+  const remoteUrlResult = preferredRemote ? runGit(commandContext, ["remote", "get-url", preferredRemote], timeoutMs) : null;
+  const remoteUrl = remoteUrlResult?.ok ? remoteUrlResult.output.trim() : undefined;
+  const displayName = parseRemoteProjectName(remoteUrl ?? "") || basename(repositoryIdentityPath) || safeBasename(currentPath);
+  const isWorktree = gitDirPath && gitCommonDirPath ? isGitWorktree(gitDirPath, gitCommonDirPath, gitMarkerDirectory) : false;
+
+  const project: ProjectInfo = {
+    displayName,
+    compactLabel: "",
+    sourcePath: currentPath,
+    isGitRepository: true,
+    gitRootPath,
+    repositoryIdentityPath,
+    branch,
+    isWorktree,
+    remoteName: preferredRemote,
+    remoteUrl,
+  };
+  project.compactLabel = buildCompactProjectLabel(project);
+  return project;
+}
+
+function buildFallbackProjectInfo(currentPath: string, displayPath = currentPath): ProjectInfo {
+  const displayName = safeBasename(displayPath);
+  const project: ProjectInfo = {
+    displayName,
+    compactLabel: displayName,
+    sourcePath: currentPath,
+    isGitRepository: false,
+  };
+  return project;
+}
+
+function resolveSearchStart(currentPath: string): string {
+  if (!currentPath) return currentPath;
+  try {
+    return statSync(currentPath).isDirectory() ? currentPath : dirname(currentPath);
+  } catch {
+    return dirname(currentPath) === currentPath ? currentPath : dirname(currentPath);
+  }
+}
+
+function findGitMarkerDirectory(startPath: string, visited: string[], cache: Map<string, ProjectInfo>): string | null {
+  let current = startPath;
+  while (current) {
+    visited.push(current);
+    const cached = cache.get(current);
+    if (cached) {
+      if (cached.isGitRepository) return null;
+    }
+    if (hasGitMarker(current)) return current;
+    const parent = dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+  return null;
+}
+
+function hasGitMarker(directory: string): boolean {
+  return existsSync(join(directory, ".git"));
+}
+
+function lookupCachedProject(currentPath: string, cache: Map<string, ProjectInfo>): ProjectInfo | undefined {
+  if (cache.has(currentPath)) return cache.get(currentPath);
+  let current = resolveSearchStart(currentPath);
+  while (current) {
+    const cached = cache.get(current);
+    if (cached) {
+      if (cached.isGitRepository) return cached;
+    }
+    const parent = dirname(current);
+    if (parent === current) return undefined;
+    current = parent;
+  }
+  return undefined;
+}
+
+function normalizeBranch(branch: string): string {
+  if (!branch || branch === "HEAD") return "detached";
+  return branch;
+}
+
+function resolveRepositoryIdentityPath(cwd: string, gitCommonDir: string, gitRootPath: string): string {
+  const resolvedGitCommonDir = resolve(cwd, gitCommonDir);
+  if (basename(resolvedGitCommonDir) !== ".git") return gitRootPath;
+  return dirname(resolvedGitCommonDir);
+}
+
+function normalizePathForLookup(currentPath: string): string {
+  return currentPath ? resolve(currentPath) : currentPath;
+}
+
+function runGit(context: string | GitCommandContext, args: string[], timeoutMs?: number): { ok: true; output: string } | { ok: false; error: string } {
+  const commandContext = typeof context === "string" ? { cwd: context } : context;
+  const gitArgs = commandContext.gitDir
+    ? ["--git-dir", commandContext.gitDir, ...(commandContext.workTree ? ["--work-tree", commandContext.workTree] : []), ...args]
+    : args;
+  return maybeRunCommandInDirectory(["git", ...gitArgs], { cwd: commandContext.cwd, timeoutMs });
+}
+
+function resolveBranchName(context: string | GitCommandContext, timeoutMs?: number): string {
+  const symbolicRef = runGit(context, ["symbolic-ref", "--quiet", "--short", "HEAD"], timeoutMs);
+  if (symbolicRef.ok) return normalizeBranch(symbolicRef.output.trim());
+  const abbreviated = runGit(context, ["rev-parse", "--abbrev-ref", "HEAD"], timeoutMs);
+  if (abbreviated.ok) return normalizeBranch(abbreviated.output.trim());
+  return "detached";
+}
+
+export function isWindowsAbsolutePath(value: string): boolean {
+  return /^[a-zA-Z]:[\\/]/.test(value.trim());
+}
+
+export function windowsPathToWslPath(value: string): string {
+  const trimmed = value.trim();
+  const drive = trimmed[0]?.toLowerCase();
+  if (!drive || !isWindowsAbsolutePath(trimmed)) return value;
+  const rest = trimmed.slice(2).replace(/\\/g, "/").replace(/^\/+/, "");
+  return `/mnt/${drive}${rest ? `/${rest}` : ""}`;
+}
+
+export function normalizeWslWindowsPath(value: string, isWsl = IS_WSL): string {
+  return isWsl && isWindowsAbsolutePath(value) ? windowsPathToWslPath(value) : value;
+}
+
+export function parseGitDirFromGitFile(contents: string): string | null {
+  const line = contents.split(/\r?\n/).find((entry) => entry.trim().toLowerCase().startsWith("gitdir:"));
+  if (!line) return null;
+  const gitDir = line.slice(line.indexOf(":") + 1).trim();
+  return gitDir || null;
+}
+
+export function resolveGitCommandContext(gitMarkerDirectory: string, isWsl = IS_WSL): GitCommandContext {
+  const gitDir = readGitFileGitDir(gitMarkerDirectory);
+  if (!gitDir) return { cwd: gitMarkerDirectory };
+
+  const normalizedGitDir = normalizeWslWindowsPath(gitDir, isWsl);
+  if (normalizedGitDir === gitDir) return { cwd: gitMarkerDirectory };
+
+  return { cwd: gitMarkerDirectory, gitDir: normalizedGitDir, workTree: gitMarkerDirectory };
+}
+
+function readGitFileGitDir(gitMarkerDirectory: string): string | null {
+  const gitPath = join(gitMarkerDirectory, ".git");
+  try {
+    if (!statSync(gitPath).isFile()) return null;
+    return parseGitDirFromGitFile(readFileSync(gitPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function trimMap<K, V>(map: Map<K, V>, maxEntries: number): void {
+  if (maxEntries <= 0) return;
+  while (map.size > maxEntries) {
+    const first = map.keys().next();
+    if (first.done) return;
+    map.delete(first.value);
+  }
+}