harulog 0.1.0

package/src/collectors/localGit.ts

@@ -0,0 +1,471 @@
+import { execFile } from "node:child_process";
+import { lstat, readdir } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+
+import type { AppConfig } from "../config";
+import type { ActivityItem } from "../types";
+import { subtractDays } from "../utils/date";
+import { logInfo, logWarn } from "../utils/logger";
+
+const execFileAsync = promisify(execFile);
+const FIELD_SEPARATOR = "\u001f";
+const RECORD_SEPARATOR = "\u001e";
+const MAX_CHANGED_FILES = 8;
+const DIRECTORY_SKIP_NAMES = new Set([
+  ".git",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  ".turbo"
+]);
+
+interface CommitSnapshot {
+  sha: string;
+  timestamp: string;
+  subject: string;
+  changedFiles: string[];
+}
+
+interface PushSnapshot {
+  sha: string;
+  timestamp: string;
+  selector: string;
+  shortRef: string;
+  message: string;
+}
+
+function tokenize(value: string): string[] {
+  return value
+    .toLowerCase()
+    .split(/[^a-z0-9가-힣]+/u)
+    .map((item) => item.trim())
+    .filter((item) => item.length >= 2);
+}
+
+function uniqueStrings(values: string[], limit = values.length): string[] {
+  const result: string[] = [];
+  const seen = new Set<string>();
+
+  for (const value of values) {
+    const trimmed = value.trim();
+    const normalized = trimmed.toLowerCase();
+    if (!trimmed || seen.has(normalized)) {
+      continue;
+    }
+
+    seen.add(normalized);
+    result.push(trimmed);
+
+    if (result.length >= limit) {
+      break;
+    }
+  }
+
+  return result;
+}
+
+function sanitizeRepoTag(repoName: string): string {
+  return repoName.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+}
+
+function sanitizeIdSegment(value: string): string {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+function summarizeFiles(files: string[]): string {
+  if (files.length === 0) {
+    return "변경 파일 정보 없음";
+  }
+
+  const visibleFiles = files.slice(0, 3).join(", ");
+  if (files.length <= 3) {
+    return visibleFiles;
+  }
+
+  return `${visibleFiles} 외 ${files.length - 3}개`;
+}
+
+function createCommitSummary(repoName: string, subject: string, files: string[]): string {
+  if (files.length === 0) {
+    return `${repoName} 저장소에서 "${subject}" 커밋이 기록되었다.`;
+  }
+
+  return `${repoName} 저장소에서 "${subject}" 커밋이 기록되었고, ${files.length}개 파일이 함께 변경되었다. 핵심 파일: ${summarizeFiles(files)}.`;
+}
+
+function createPushSummary(
+  repoName: string,
+  push: PushSnapshot,
+  commit: CommitSnapshot | null
+): string {
+  const refName = push.shortRef;
+  if (!commit) {
+    return `${repoName} 저장소에서 ${refName} 기준 push 이력이 감지되었다. reflog 메시지: ${push.message}.`;
+  }
+
+  if (commit.changedFiles.length === 0) {
+    return `${repoName} 저장소에서 ${refName} 기준 push 이력이 감지되었다. 관련 커밋은 "${commit.subject}"였다.`;
+  }
+
+  return `${repoName} 저장소에서 ${refName} 기준 push 이력이 감지되었다. 관련 커밋은 "${commit.subject}"였고, 함께 바뀐 파일은 ${summarizeFiles(commit.changedFiles)}다.`;
+}
+
+function createTags(repoName: string, subject: string, files: string[], extra: string[] = []): string[] {
+  const fileTokens = files.flatMap((item) => tokenize(path.basename(item)));
+  return uniqueStrings(
+    [sanitizeRepoTag(repoName), ...tokenize(subject), ...fileTokens, ...extra.flatMap(tokenize)],
+    8
+  );
+}
+
+async function pathExists(targetPath: string): Promise<boolean> {
+  try {
+    await lstat(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function runGit(repoPath: string, args: string[]): Promise<string> {
+  const { stdout } = await execFileAsync("git", ["-c", "core.quotepath=false", ...args], {
+    cwd: repoPath,
+    maxBuffer: 1024 * 1024 * 8
+  });
+
+  return stdout;
+}
+
+async function isGitRepository(repoPath: string): Promise<boolean> {
+  return pathExists(path.join(repoPath, ".git"));
+}
+
+async function discoverGitRepos(rootPath: string, maxDepth: number): Promise<string[]> {
+  if (!(await pathExists(rootPath))) {
+    logWarn(`Local git scan root not found: ${rootPath}`);
+    return [];
+  }
+
+  const discovered: string[] = [];
+  const queue: Array<{ dirPath: string; depth: number }> = [{ dirPath: rootPath, depth: 0 }];
+  const visited = new Set<string>();
+
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current || visited.has(current.dirPath)) {
+      continue;
+    }
+
+    visited.add(current.dirPath);
+
+    if (await isGitRepository(current.dirPath)) {
+      discovered.push(current.dirPath);
+      continue;
+    }
+
+    if (current.depth >= maxDepth) {
+      continue;
+    }
+
+    let entries;
+    try {
+      entries = await readdir(current.dirPath, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+
+      if (DIRECTORY_SKIP_NAMES.has(entry.name)) {
+        continue;
+      }
+
+      if (entry.name.startsWith(".") && entry.name !== ".config") {
+        continue;
+      }
+
+      queue.push({
+        dirPath: path.join(current.dirPath, entry.name),
+        depth: current.depth + 1
+      });
+    }
+  }
+
+  return discovered;
+}
+
+function parseCommitLog(output: string): CommitSnapshot[] {
+  return output
+    .split(RECORD_SEPARATOR)
+    .map((record) => record.trim())
+    .filter(Boolean)
+    .map((record) => {
+      const lines = record.split("\n").map((line) => line.trimEnd());
+      const [sha = "", timestamp = "", subject = ""] = (lines.shift() ?? "").split(FIELD_SEPARATOR);
+      const changedFiles = uniqueStrings(
+        lines.map((line) => line.trim()).filter(Boolean),
+        MAX_CHANGED_FILES
+      );
+
+      return {
+        sha: sha.trim(),
+        timestamp: timestamp.trim(),
+        subject: subject.trim(),
+        changedFiles
+      };
+    })
+    .filter((record) => record.sha && record.timestamp && record.subject);
+}
+
+function parseReflogTimestamp(selector: string): string | null {
+  const match = selector.match(/@\{(.+)\}$/);
+  return match?.[1]?.trim() || null;
+}
+
+function parsePushLog(output: string): PushSnapshot[] {
+  return output
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      const [sha = "", selector = "", message = ""] = line.split(FIELD_SEPARATOR);
+      const timestamp = parseReflogTimestamp(selector) ?? "";
+      const shortRef = selector.includes("@{") ? selector.slice(0, selector.indexOf("@{")) : selector;
+
+      return {
+        sha: sha.trim(),
+        timestamp,
+        selector: selector.trim(),
+        shortRef: shortRef.trim(),
+        message: message.trim()
+      };
+    })
+    .filter((record) => record.sha && record.timestamp && record.shortRef)
+    .filter((record) => record.shortRef !== "origin/HEAD")
+    .filter((record) => record.message.toLowerCase().includes("push"));
+}
+
+async function loadCommitSnapshots(repoPath: string, sinceIso: string): Promise<CommitSnapshot[]> {
+  const output = await runGit(repoPath, [
+    "log",
+    `--since=${sinceIso}`,
+    "--date=iso-strict",
+    `--pretty=format:${RECORD_SEPARATOR}%H${FIELD_SEPARATOR}%cI${FIELD_SEPARATOR}%s`,
+    "--name-only"
+  ]);
+
+  return parseCommitLog(output);
+}
+
+async function loadCommitSnapshotForSha(
+  repoPath: string,
+  sha: string,
+  fallbackTimestamp: string
+): Promise<CommitSnapshot | null> {
+  try {
+    const output = await runGit(repoPath, [
+      "show",
+      "--date=iso-strict",
+      `--pretty=format:${RECORD_SEPARATOR}%H${FIELD_SEPARATOR}%cI${FIELD_SEPARATOR}%s`,
+      "--name-only",
+      sha
+    ]);
+
+    const snapshot = parseCommitLog(output)[0];
+    if (!snapshot) {
+      return null;
+    }
+
+    return {
+      ...snapshot,
+      timestamp: snapshot.timestamp || fallbackTimestamp
+    };
+  } catch {
+    return null;
+  }
+}
+
+async function loadRemoteRefs(repoPath: string): Promise<string[]> {
+  try {
+    const output = await runGit(repoPath, ["for-each-ref", "--format=%(refname:short)", "refs/remotes"]);
+    return output
+      .split("\n")
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .filter((ref) => !ref.endsWith("/HEAD"));
+  } catch {
+    return [];
+  }
+}
+
+async function loadPushSnapshots(repoPath: string): Promise<PushSnapshot[]> {
+  const remoteRefs = await loadRemoteRefs(repoPath);
+  if (remoteRefs.length === 0) {
+    return [];
+  }
+
+  const outputs = await Promise.all(
+    remoteRefs.map(async (remoteRef) => {
+      try {
+        const output = await runGit(repoPath, [
+          "reflog",
+          "show",
+          remoteRef,
+          "--date=iso-strict",
+          `--format=%H${FIELD_SEPARATOR}%gd${FIELD_SEPARATOR}%gs`,
+          "-n",
+          "30"
+        ]);
+        return parsePushLog(output);
+      } catch {
+        return [];
+      }
+    })
+  );
+
+  const deduped = new Map<string, PushSnapshot>();
+  for (const push of outputs.flat()) {
+    const key = `${push.shortRef}:${push.timestamp}:${push.sha}`;
+    if (!deduped.has(key)) {
+      deduped.set(key, push);
+    }
+  }
+
+  return [...deduped.values()];
+}
+
+function toCommitActivity(repoPath: string, commit: CommitSnapshot): ActivityItem {
+  const repoName = path.basename(repoPath);
+  const shortSha = commit.sha.slice(0, 7);
+
+  return {
+    id: `git:commit:${sanitizeIdSegment(repoName)}:${commit.sha}`,
+    source: "git",
+    type: "commit",
+    title: `[${repoName}] ${commit.subject}`,
+    summary: createCommitSummary(repoName, commit.subject, commit.changedFiles),
+    timestamp: commit.timestamp,
+    tags: createTags(repoName, commit.subject, commit.changedFiles, ["commit"]),
+    weight: 3,
+    status: "done",
+    evidence: [
+      `${repoName}@${shortSha}`,
+      ...commit.changedFiles.slice(0, 4).map((filePath) => `${repoName}/${filePath}`)
+    ],
+    metadata: {
+      repoName,
+      commitSha: commit.sha,
+      changedFiles: commit.changedFiles,
+      changedFileCount: commit.changedFiles.length,
+      shortSha
+    }
+  };
+}
+
+function toPushActivity(repoPath: string, push: PushSnapshot, commit: CommitSnapshot | null): ActivityItem {
+  const repoName = path.basename(repoPath);
+  const branchName = push.shortRef.includes("/") ? push.shortRef.split("/").slice(1).join("/") : push.shortRef;
+  const shortSha = push.sha.slice(0, 7);
+  const changedFiles = commit?.changedFiles ?? [];
+  const subject = commit?.subject ?? `push to ${push.shortRef}`;
+
+  return {
+    id: `git:push:${sanitizeIdSegment(repoName)}:${sanitizeIdSegment(push.shortRef)}:${push.timestamp}:${push.sha}`,
+    source: "git",
+    type: "push",
+    title: `[${repoName}] ${branchName} push`,
+    summary: createPushSummary(repoName, push, commit),
+    timestamp: push.timestamp,
+    tags: createTags(repoName, subject, changedFiles, ["push", branchName]),
+    weight: 2.6,
+    status: "done",
+    evidence: [`${repoName}@${shortSha}`, push.shortRef, ...changedFiles.slice(0, 3).map((filePath) => `${repoName}/${filePath}`)],
+    metadata: {
+      repoName,
+      branchName,
+      remoteRef: push.shortRef,
+      pushMessage: push.message,
+      commitSha: push.sha,
+      relatedCommitTitle: commit?.subject ?? null,
+      changedFiles,
+      changedFileCount: changedFiles.length,
+      shortSha
+    }
+  };
+}
+
+async function collectRepoActivities(
+  repoPath: string,
+  sinceIso: string
+): Promise<ActivityItem[]> {
+  const commits = await loadCommitSnapshots(repoPath, sinceIso);
+  const commitMap = new Map(commits.map((commit) => [commit.sha, commit]));
+  const pushes = (await loadPushSnapshots(repoPath)).filter((push) => {
+    return new Date(push.timestamp).getTime() >= new Date(sinceIso).getTime();
+  });
+
+  const pushActivities: ActivityItem[] = [];
+  for (const push of pushes) {
+    let commit = commitMap.get(push.sha) ?? null;
+    if (!commit) {
+      commit = await loadCommitSnapshotForSha(repoPath, push.sha, push.timestamp);
+      if (commit) {
+        commitMap.set(commit.sha, commit);
+      }
+    }
+
+    pushActivities.push(toPushActivity(repoPath, push, commit));
+  }
+
+  return [...commits.map((commit) => toCommitActivity(repoPath, commit)), ...pushActivities];
+}
+
+export async function listLocalGitRepositories(config: AppConfig): Promise<string[]> {
+  const explicitRepos = config.localGitRepos;
+  const discoveredRepos = (
+    await Promise.all(config.localGitScanRoots.map((rootPath) => discoverGitRepos(rootPath, config.localGitScanDepth)))
+  ).flat();
+
+  const repoPaths = Array.from(new Set([...explicitRepos, ...discoveredRepos])).sort();
+  if (repoPaths.length === 0) {
+    logWarn("Local git collector found no repositories to inspect.");
+    return [];
+  }
+
+  return repoPaths;
+}
+
+export async function collectLocalGitActivities(
+  config: AppConfig,
+  now = new Date()
+): Promise<ActivityItem[]> {
+  const repoPaths = await listLocalGitRepositories(config);
+  if (repoPaths.length === 0) {
+    return [];
+  }
+
+  const sinceIso = subtractDays(now, config.recommendationWindowDays).toISOString();
+  logInfo(`Local git collector inspecting ${repoPaths.length} repositories.`);
+
+  const results = await Promise.allSettled(
+    repoPaths.map(async (repoPath) => collectRepoActivities(repoPath, sinceIso))
+  );
+
+  const activities: ActivityItem[] = [];
+  for (const [index, result] of results.entries()) {
+    if (result.status === "fulfilled") {
+      activities.push(...result.value);
+      continue;
+    }
+
+    logWarn(`Local git collector skipped ${repoPaths[index]}: ${String(result.reason)}`);
+  }
+
+  return activities;
+}

package/src/config.ts

@@ -0,0 +1,225 @@
+import os from "node:os";
+import path from "node:path";
+import { existsSync } from "node:fs";
+
+import { LAUNCH_AGENT_LABEL, resolveAppPaths, type AppPaths } from "./appPaths";
+import type { LlmProvider } from "./types";
+import { pathExists, readJsonFile, writeJsonFile } from "./utils/file";
+
+export interface UserConfig {
+  llmProvider?: LlmProvider;
+  geminiApiKey?: string;
+  geminiApiKeySource?: "config" | "env";
+  geminiModel?: string;
+  codexHome?: string;
+  localGitRepos?: string[];
+  localGitScanRoots?: string[];
+  localGitScanDepth?: number;
+  schedule?: {
+    weekday?: number;
+    hour?: number;
+  };
+  topicCount?: number;
+  recommendationWindowDays?: number;
+}
+
+export interface AppConfig extends AppPaths {
+  packageName: string;
+  packageVersion: string;
+  configExists: boolean;
+  llmProvider: LlmProvider;
+  geminiApiKey?: string;
+  geminiApiKeySource: "config" | "env";
+  geminiModel: string;
+  codexHome: string;
+  codexSessionIndexPath: string;
+  codexLogsPath: string;
+  topicCount: number;
+  recommendationWindowDays: number;
+  scheduleHour: number;
+  scheduleWeekday: number;
+  localGitRepos: string[];
+  localGitScanRoots: string[];
+  localGitScanDepth: number;
+  launchAgentLabel: string;
+}
+
+interface PackageManifest {
+  name?: string;
+  version?: string;
+}
+
+function resolveHomePath(value: string | undefined, fallback: string): string {
+  const raw = value?.trim();
+  if (!raw) {
+    return fallback;
+  }
+
+  if (raw === "~") {
+    return os.homedir();
+  }
+
+  if (raw.startsWith("~/")) {
+    return path.join(os.homedir(), raw.slice(2));
+  }
+
+  return raw;
+}
+
+function readPositiveInteger(value: string | number | undefined, fallback: number): number {
+  const parsed =
+    typeof value === "number" ? value : Number.parseInt(typeof value === "string" ? value : "", 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return fallback;
+  }
+
+  return parsed;
+}
+
+function readWeekday(value: string | number | undefined, fallback: number): number {
+  const parsed =
+    typeof value === "number" ? value : Number.parseInt(typeof value === "string" ? value : "", 10);
+  if (!Number.isFinite(parsed) || parsed < 0 || parsed > 6) {
+    return fallback;
+  }
+
+  return parsed;
+}
+
+function normalizePathInput(value: string, baseDir: string): string {
+  const resolved = resolveHomePath(value, baseDir);
+  return path.isAbsolute(resolved) ? path.normalize(resolved) : path.resolve(baseDir, resolved);
+}
+
+function normalizePathList(values: string[] | undefined, baseDir: string): string[] {
+  if (!Array.isArray(values)) {
+    return [];
+  }
+
+  return Array.from(
+    new Set(
+      values
+        .map((item) => item.trim())
+        .filter(Boolean)
+        .map((item) => normalizePathInput(item, baseDir))
+    )
+  );
+}
+
+function readEnvPathList(value: string | undefined, baseDir: string): string[] {
+  if (!value?.trim()) {
+    return [];
+  }
+
+  return normalizePathList(value.split(/[\n,]+/), baseDir);
+}
+
+async function loadPackageManifest(paths: AppPaths): Promise<PackageManifest> {
+  return readJsonFile<PackageManifest>(paths.packageManifestPath, {});
+}
+
+export async function loadUserConfig(paths = resolveAppPaths()): Promise<UserConfig> {
+  return readJsonFile<UserConfig>(paths.configPath, {});
+}
+
+export async function saveUserConfig(config: UserConfig, paths = resolveAppPaths()): Promise<void> {
+  await writeJsonFile(paths.configPath, config);
+}
+
+export function getDefaultLocalGitScanRoots(): string[] {
+  const home = os.homedir();
+  const candidates = [
+    path.join(home, "Documents", "work"),
+    path.join(home, "Documents"),
+    home
+  ];
+
+  const firstExisting = candidates.find((candidate) => existsSync(candidate));
+  return firstExisting ? [firstExisting] : [home];
+}
+
+function resolveLocalGitScanRoots(
+  userConfig: UserConfig,
+  baseDir: string
+): string[] {
+  const envValue = process.env.LOCAL_GIT_SCAN_ROOTS;
+  if (envValue?.trim()) {
+    const normalized = envValue.trim().toLowerCase();
+    if (normalized === "off" || normalized === "none" || normalized === "disabled") {
+      return [];
+    }
+
+    const fromEnv = readEnvPathList(envValue, baseDir);
+    if (fromEnv.length > 0) {
+      return fromEnv;
+    }
+  }
+
+  const fromConfig = normalizePathList(userConfig.localGitScanRoots, baseDir);
+  if (fromConfig.length > 0) {
+    return fromConfig;
+  }
+
+  return getDefaultLocalGitScanRoots().map((candidate) => normalizePathInput(candidate, baseDir));
+}
+
+export async function loadConfig(): Promise<AppConfig> {
+  const paths = resolveAppPaths();
+  const packageManifest = await loadPackageManifest(paths);
+  const userConfig = await loadUserConfig(paths);
+  const configExists = await pathExists(paths.configPath);
+
+  const llmProvider =
+    process.env.LLM_PROVIDER?.trim().toLowerCase() === "placeholder"
+      ? "placeholder"
+      : userConfig.llmProvider ?? "gemini";
+  const geminiApiKeyFromEnv =
+    process.env.GEMINI_API_KEY?.trim() || process.env.GOOGLE_API_KEY?.trim() || undefined;
+  const geminiApiKey = geminiApiKeyFromEnv || userConfig.geminiApiKey || undefined;
+  const geminiApiKeySource: "config" | "env" = geminiApiKeyFromEnv
+    ? "env"
+    : userConfig.geminiApiKey
+      ? "config"
+      : userConfig.geminiApiKeySource ?? "env";
+  const codexHome = normalizePathInput(
+    process.env.CODEX_HOME?.trim() || userConfig.codexHome || path.join(os.homedir(), ".codex"),
+    paths.packageRoot
+  );
+
+  return {
+    ...paths,
+    packageName: packageManifest.name?.trim() || "harulog",
+    packageVersion: packageManifest.version?.trim() || "0.0.0",
+    configExists,
+    llmProvider,
+    geminiApiKey,
+    geminiApiKeySource,
+    geminiModel:
+      process.env.GEMINI_MODEL?.trim() ||
+      userConfig.geminiModel?.trim() ||
+      "gemini-2.5-flash",
+    codexHome,
+    codexSessionIndexPath: path.join(codexHome, "session_index.jsonl"),
+    codexLogsPath: path.join(codexHome, "logs_1.sqlite"),
+    topicCount: readPositiveInteger(process.env.TOPIC_COUNT ?? userConfig.topicCount, 5),
+    recommendationWindowDays: readPositiveInteger(
+      process.env.RECOMMENDATION_WINDOW_DAYS ?? userConfig.recommendationWindowDays,
+      14
+    ),
+    scheduleHour: readPositiveInteger(process.env.SCHEDULE_HOUR ?? userConfig.schedule?.hour, 9),
+    scheduleWeekday: readWeekday(
+      process.env.SCHEDULE_WEEKDAY ?? userConfig.schedule?.weekday,
+      5
+    ),
+    localGitRepos:
+      readEnvPathList(process.env.LOCAL_GIT_REPOS, paths.packageRoot).length > 0
+        ? readEnvPathList(process.env.LOCAL_GIT_REPOS, paths.packageRoot)
+        : normalizePathList(userConfig.localGitRepos, paths.packageRoot),
+    localGitScanRoots: resolveLocalGitScanRoots(userConfig, paths.packageRoot),
+    localGitScanDepth: readPositiveInteger(
+      process.env.LOCAL_GIT_SCAN_DEPTH ?? userConfig.localGitScanDepth,
+      2
+    ),
+    launchAgentLabel: LAUNCH_AGENT_LABEL
+  };
+}