@gokulvenkatareddy/cortex 0.1.7

package/apps/octogent/apps/api/src/claudeSessionScanner.ts

@@ -0,0 +1,235 @@
+import { readFile, readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const CLAUDE_PROJECTS_DIR = join(homedir(), ".claude", "projects");
+
+export type UsageSlice = {
+  key: string;
+  tokens: number;
+};
+
+export type UsageDayEntry = {
+  date: string;
+  totalTokens: number;
+  projects: UsageSlice[];
+  models: UsageSlice[];
+  sessions: number;
+};
+
+export type UsageChartResponse = {
+  days: UsageDayEntry[];
+  projects: string[];
+  models: string[];
+};
+
+type AssistantEvent = {
+  type: string;
+  timestamp: string;
+  sessionId: string;
+  message?: {
+    model?: string;
+    usage?: {
+      input_tokens?: number;
+      output_tokens?: number;
+      cache_creation_input_tokens?: number;
+      cache_read_input_tokens?: number;
+    };
+  };
+};
+
+const isAssistantEvent = (value: unknown): value is AssistantEvent => {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value as Record<string, unknown>;
+  return record.type === "assistant" && typeof record.timestamp === "string";
+};
+
+const toDateKey = (timestamp: string): string | null => {
+  const parsed = Date.parse(timestamp);
+  if (!Number.isFinite(parsed)) return null;
+  return new Date(parsed).toISOString().slice(0, 10);
+};
+
+type DayBucket = {
+  totalTokens: number;
+  projectTokens: Map<string, number>;
+  modelTokens: Map<string, number>;
+  sessions: Set<string>;
+};
+
+const scanJsonlFile = async (
+  filePath: string,
+  projectLabel: string,
+  buckets: Map<string, DayBucket>,
+): Promise<void> => {
+  let content: string;
+  try {
+    content = await readFile(filePath, "utf8");
+  } catch {
+    return;
+  }
+
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+
+    if (!isAssistantEvent(parsed)) continue;
+
+    const dateKey = toDateKey(parsed.timestamp);
+    if (!dateKey) continue;
+
+    const usage = parsed.message?.usage;
+    if (!usage) continue;
+
+    const totalTokens =
+      (usage.input_tokens ?? 0) +
+      (usage.output_tokens ?? 0) +
+      (usage.cache_creation_input_tokens ?? 0) +
+      (usage.cache_read_input_tokens ?? 0);
+
+    if (totalTokens === 0) continue;
+
+    let bucket = buckets.get(dateKey);
+    if (!bucket) {
+      bucket = {
+        totalTokens: 0,
+        projectTokens: new Map(),
+        modelTokens: new Map(),
+        sessions: new Set(),
+      };
+      buckets.set(dateKey, bucket);
+    }
+
+    bucket.totalTokens += totalTokens;
+    bucket.projectTokens.set(
+      projectLabel,
+      (bucket.projectTokens.get(projectLabel) ?? 0) + totalTokens,
+    );
+
+    const modelKey = parsed.message?.model ?? "unknown";
+    bucket.modelTokens.set(modelKey, (bucket.modelTokens.get(modelKey) ?? 0) + totalTokens);
+
+    if (parsed.sessionId) {
+      bucket.sessions.add(parsed.sessionId);
+    }
+  }
+};
+
+const scanProjectDirectory = async (
+  projectDir: string,
+  projectLabel: string,
+  buckets: Map<string, DayBucket>,
+): Promise<void> => {
+  let entries: string[];
+  try {
+    entries = await readdir(projectDir);
+  } catch {
+    return;
+  }
+
+  const jsonlFiles = entries.filter((entry) => entry.endsWith(".jsonl"));
+  await Promise.all(
+    jsonlFiles.map((file) => scanJsonlFile(join(projectDir, file), projectLabel, buckets)),
+  );
+};
+
+const slugToLabel = (slug: string): string => {
+  const parts = slug.replace(/^-/, "").split("-");
+  const codebaseIndex = parts.findIndex((p) => p.toLowerCase() === "codebase");
+  const relevant = codebaseIndex >= 0 ? parts.slice(codebaseIndex + 1) : parts.slice(-1);
+  if (relevant.length === 0) return slug;
+
+  const joined = relevant.join("-");
+  const worktreeMatch = joined.match(/^(.+?)--.*?-worktrees-(.+)$/);
+  if (worktreeMatch) {
+    return `${worktreeMatch[1]}/${worktreeMatch[2]}`;
+  }
+  return joined;
+};
+
+const sortedKeys = (totals: Map<string, number>): string[] =>
+  Array.from(totals.entries())
+    .sort((a, b) => b[1] - a[1])
+    .map(([name]) => name);
+
+const mapToSlices = (map: Map<string, number>): UsageSlice[] =>
+  Array.from(map.entries())
+    .map(([key, tokens]) => ({ key, tokens }))
+    .sort((a, b) => b.tokens - a.tokens);
+
+const projectSlugFromCwd = (cwd: string): string => cwd.replace(/\//g, "-");
+
+let cachedResult: { response: UsageChartResponse; fetchedAt: number; cacheKey: string } | null =
+  null;
+const CACHE_TTL_MS = 120_000;
+
+export const scanClaudeUsageChart = async (
+  scope: "all" | "project",
+  workspaceCwd: string,
+): Promise<UsageChartResponse> => {
+  const projectSlug = scope === "project" ? projectSlugFromCwd(workspaceCwd) : null;
+  const cacheKey = `${scope}:${projectSlug ?? "all"}`;
+
+  if (
+    cachedResult &&
+    Date.now() - cachedResult.fetchedAt < CACHE_TTL_MS &&
+    cachedResult.cacheKey === cacheKey
+  ) {
+    return cachedResult.response;
+  }
+
+  const buckets = new Map<string, DayBucket>();
+
+  if (scope === "project" && projectSlug) {
+    const label = slugToLabel(projectSlug);
+    await scanProjectDirectory(join(CLAUDE_PROJECTS_DIR, projectSlug), label, buckets);
+  } else {
+    let projectDirs: string[];
+    try {
+      projectDirs = await readdir(CLAUDE_PROJECTS_DIR);
+    } catch {
+      projectDirs = [];
+    }
+    await Promise.all(
+      projectDirs.map((dir) =>
+        scanProjectDirectory(join(CLAUDE_PROJECTS_DIR, dir), slugToLabel(dir), buckets),
+      ),
+    );
+  }
+
+  const projectTotals = new Map<string, number>();
+  const modelTotals = new Map<string, number>();
+
+  const days: UsageDayEntry[] = Array.from(buckets.entries())
+    .map(([date, bucket]) => {
+      for (const [p, t] of bucket.projectTokens) {
+        projectTotals.set(p, (projectTotals.get(p) ?? 0) + t);
+      }
+      for (const [m, t] of bucket.modelTokens) {
+        modelTotals.set(m, (modelTotals.get(m) ?? 0) + t);
+      }
+      return {
+        date,
+        totalTokens: bucket.totalTokens,
+        projects: mapToSlices(bucket.projectTokens),
+        models: mapToSlices(bucket.modelTokens),
+        sessions: bucket.sessions.size,
+      };
+    })
+    .sort((a, b) => a.date.localeCompare(b.date));
+
+  const response: UsageChartResponse = {
+    days,
+    projects: sortedKeys(projectTotals),
+    models: sortedKeys(modelTotals),
+  };
+  cachedResult = { response, fetchedAt: Date.now(), cacheKey };
+  return response;
+};

package/apps/octogent/apps/api/src/claudeSkills.ts

@@ -0,0 +1,182 @@
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+
+import type { DeckAvailableSkill } from "@octogent/core";
+
+const SKILL_MARKER_START = "<!-- octogent:suggested-skills:start -->";
+const SKILL_MARKER_END = "<!-- octogent:suggested-skills:end -->";
+const FRONT_MATTER_PATTERN = /^---\n([\s\S]*?)\n---\n?/;
+const H1_PATTERN = /^#\s+(.+)$/m;
+
+const normalizeSkillNames = (skills: readonly string[]): string[] => {
+  const seen = new Set<string>();
+  const normalized: string[] = [];
+
+  for (const skill of skills) {
+    const trimmed = skill.trim();
+    if (trimmed.length === 0 || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    normalized.push(trimmed);
+  }
+
+  return normalized.sort((a, b) => a.localeCompare(b));
+};
+
+const readSkillMetadata = (
+  skillFilePath: string,
+): { name: string; description: string; title: string | null } => {
+  const fallbackName =
+    basename(skillFilePath, ".md") === "SKILL"
+      ? basename(dirname(skillFilePath))
+      : basename(skillFilePath, ".md");
+  try {
+    const content = readFileSync(skillFilePath, "utf8");
+    const frontMatterMatch = content.match(FRONT_MATTER_PATTERN);
+    let name: string | null = null;
+    let description = "";
+
+    if (frontMatterMatch) {
+      for (const line of (frontMatterMatch[1] ?? "").split("\n")) {
+        const separatorIndex = line.indexOf(":");
+        if (separatorIndex <= 0) continue;
+
+        const key = line.slice(0, separatorIndex).trim();
+        const rawValue = line.slice(separatorIndex + 1).trim();
+        const value = rawValue.replace(/^['"]|['"]$/g, "");
+        if (key === "name" && value.length > 0) {
+          name = value;
+        } else if (key === "description" && value.length > 0) {
+          description = value;
+        }
+      }
+    }
+
+    const title = content.match(H1_PATTERN)?.[1]?.trim() ?? null;
+    return {
+      name: name ?? title ?? fallbackName,
+      description,
+      title,
+    };
+  } catch {
+    return {
+      name: fallbackName,
+      description: "",
+      title: null,
+    };
+  }
+};
+
+const listSkillDefinitionFiles = (skillsRoot: string): string[] => {
+  if (!existsSync(skillsRoot)) return [];
+
+  const definitions: string[] = [];
+
+  let entries: string[] = [];
+  try {
+    entries = readdirSync(skillsRoot);
+  } catch {
+    return definitions;
+  }
+
+  for (const entry of entries) {
+    const entryPath = join(skillsRoot, entry);
+    try {
+      if (!statSync(entryPath).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+
+    const skillFile = join(entryPath, "SKILL.md");
+    if (existsSync(skillFile)) {
+      definitions.push(skillFile);
+    }
+  }
+
+  return definitions;
+};
+
+export const readAvailableClaudeSkills = (workspaceCwd: string): DeckAvailableSkill[] => {
+  const roots: Array<{ path: string; source: DeckAvailableSkill["source"] }> = [
+    { path: join(workspaceCwd, ".claude", "skills"), source: "project" },
+  ];
+
+  const seen = new Map<string, DeckAvailableSkill>();
+
+  for (const root of roots) {
+    const definitions = listSkillDefinitionFiles(root.path);
+    for (const definition of definitions) {
+      const metadata = readSkillMetadata(definition);
+      const name = metadata.name.trim();
+      if (name.length === 0 || seen.has(name)) continue;
+      seen.set(name, {
+        name,
+        description: metadata.description,
+        source: root.source,
+      });
+    }
+  }
+
+  return [...seen.values()].sort((a, b) => {
+    if (a.source !== b.source) {
+      return a.source === "project" ? -1 : 1;
+    }
+    return a.name.localeCompare(b.name);
+  });
+};
+
+export const parseSuggestedSkillsFromContext = (content: string): string[] => {
+  const start = content.indexOf(SKILL_MARKER_START);
+  const end = content.indexOf(SKILL_MARKER_END);
+  if (start < 0 || end < 0 || end <= start) return [];
+
+  const block = content.slice(start, end);
+  const skills = block
+    .split("\n")
+    .map((line) => {
+      const match = line.trim().match(/^- `(.+)`$/);
+      return match?.[1]?.trim() ?? null;
+    })
+    .filter((skill): skill is string => skill !== null);
+
+  return normalizeSkillNames(skills);
+};
+
+const renderSuggestedSkillsBlock = (skills: readonly string[]): string => {
+  const normalized = normalizeSkillNames(skills);
+  if (normalized.length === 0) return "";
+
+  const items = normalized.map((skill) => `- \`${skill}\``).join("\n");
+  return [
+    SKILL_MARKER_START,
+    "## Suggested Skills",
+    "",
+    "You can use these skills if you need to.",
+    "",
+    items,
+    SKILL_MARKER_END,
+  ].join("\n");
+};
+
+export const applySuggestedSkillsToContext = (
+  content: string,
+  skills: readonly string[],
+): string => {
+  const trimmedContent = content.trimEnd();
+  const start = trimmedContent.indexOf(SKILL_MARKER_START);
+  const end = trimmedContent.indexOf(SKILL_MARKER_END);
+  const block = renderSuggestedSkillsBlock(skills);
+
+  let withoutExistingBlock = trimmedContent;
+  if (start >= 0 && end > start) {
+    withoutExistingBlock = `${trimmedContent.slice(0, start).trimEnd()}\n${trimmedContent
+      .slice(end + SKILL_MARKER_END.length)
+      .trimStart()}`.trimEnd();
+  }
+
+  if (block.length === 0) {
+    return `${withoutExistingBlock}\n`;
+  }
+
+  const base = withoutExistingBlock.length > 0 ? `${withoutExistingBlock}\n\n` : "";
+  return `${base}${block}\n`;
+};