project-athena 0.2.1 → 0.3.0

package/dist/chunk-2DY4PUR4.js

@@ -0,0 +1,465 @@
+#!/usr/bin/env node
+import {
+  readTextIfExists,
+  writeFileAtomic
+} from "./chunk-IQQBAWSM.js";
+import {
+  ATHENA_DIR
+} from "./chunk-EUPETUWA.js";
+
+// src/core/config.ts
+import path from "path";
+import { z } from "zod";
+var DEFAULT_IGNORES = [
+  ".git",
+  ".hg",
+  ".svn",
+  "node_modules",
+  "bower_components",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  ".turbo",
+  ".cache",
+  ".parcel-cache",
+  ".dart_tool",
+  ".venv",
+  "venv",
+  ".tox",
+  "__pycache__",
+  ".pytest_cache",
+  ".mypy_cache",
+  "target",
+  "coverage",
+  ".gradle",
+  ".idea",
+  "vendor",
+  "Pods",
+  ".terraform",
+  ".serverless",
+  ATHENA_DIR,
+  `${ATHENA_DIR}.tmp-*`
+];
+var AthenaConfig = z.object({
+  /** Additional gitignore-style patterns to exclude. */
+  ignore: z.array(z.string()).default([]),
+  /** Patterns (gitignore-style) to force-include even if a default ignore matches. */
+  include: z.array(z.string()).default([]),
+  /** Files larger than this are indexed by metadata only. */
+  maxFileBytes: z.number().int().positive().default(1e6),
+  /** Hard cap on files scanned; beyond this analysis stops and warns. */
+  maxFiles: z.number().int().positive().default(2e5),
+  /** Agent adapters to configure. Empty = auto. */
+  agents: z.array(z.string()).optional(),
+  /** Optional AI provider settings (see `athena ai status`). AI is never required. */
+  ai: z.object({
+    provider: z.enum(["anthropic", "openai", "google", "ollama"]).optional(),
+    model: z.string().optional(),
+    mode: z.enum(["cloud", "local"]).optional(),
+    consent: z.boolean().optional(),
+    maxChars: z.number().int().min(500).max(2e5).optional(),
+    baseUrl: z.string().optional()
+  }).optional()
+});
+async function loadConfig(root) {
+  const file = path.join(root, ATHENA_DIR, "config.json");
+  const raw = await readTextIfExists(file);
+  if (raw === null) return { config: AthenaConfig.parse({}) };
+  try {
+    const parsed = AthenaConfig.safeParse(JSON.parse(raw));
+    if (parsed.success) return { config: parsed.data };
+    return { config: AthenaConfig.parse({}), warning: `.athena/config.json is invalid (${parsed.error.issues[0]?.message}); using defaults` };
+  } catch {
+    return { config: AthenaConfig.parse({}), warning: ".athena/config.json is not valid JSON; using defaults" };
+  }
+}
+
+// src/core/cache/facts-cache.ts
+import { promises as fs } from "fs";
+import path2 from "path";
+var CACHE_DIR = path2.join("cache", "v1");
+var FACTS_DIR = "facts";
+var VERSION_FILE = "version.json";
+var FACTS_FORMAT = 1;
+var shardOf = (hash) => hash.slice(0, 2);
+function cacheRoot(athenaDir2) {
+  return path2.join(athenaDir2, CACHE_DIR);
+}
+var FactsCache = class _FactsCache {
+  constructor(dir, identity, reset) {
+    this.dir = dir;
+    this.identity = identity;
+    this.reset = reset;
+    this.stats.reset = reset;
+  }
+  dir;
+  identity;
+  reset;
+  shards = /* @__PURE__ */ new Map();
+  loading = /* @__PURE__ */ new Map();
+  dirty = /* @__PURE__ */ new Set();
+  /** Facts that must not be persisted (e.g. keyed with an ephemeral per-process key). */
+  transient = /* @__PURE__ */ new Map();
+  stats = { shardsLoaded: 0, corruptShards: 0, shardsWritten: 0, reset: false };
+  static async open(athenaDir2, identity) {
+    if (!athenaDir2) return new _FactsCache(null, identity, false);
+    const dir = cacheRoot(athenaDir2);
+    let reset = true;
+    try {
+      const v = JSON.parse(await fs.readFile(path2.join(dir, FACTS_DIR, VERSION_FILE), "utf8"));
+      reset = v.format !== FACTS_FORMAT || v.detectors !== identity.detectors || v.config !== identity.config;
+    } catch {
+    }
+    return new _FactsCache(reset ? null : dir, identity, reset);
+  }
+  shard(prefix) {
+    const loaded = this.shards.get(prefix);
+    if (loaded) return loaded;
+    let p = this.loading.get(prefix);
+    if (!p) {
+      p = this.loadShard(prefix);
+      this.loading.set(prefix, p);
+    }
+    return p;
+  }
+  async loadShard(prefix) {
+    let data = {};
+    if (this.dir) {
+      try {
+        const raw = await fs.readFile(path2.join(this.dir, FACTS_DIR, `${prefix}.json`), "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          data = parsed;
+          this.stats.shardsLoaded++;
+        } else throw new Error("bad shard");
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+          this.stats.corruptShards++;
+          data = {};
+          this.dirty.add(prefix);
+        }
+      }
+    }
+    this.shards.set(prefix, data);
+    this.loading.delete(prefix);
+    return data;
+  }
+  /** Load the shards for these hashes (in parallel) so get/has can run synchronously. */
+  async preload(hashes) {
+    const prefixes = /* @__PURE__ */ new Set();
+    for (const h of hashes) if (isContentHash(h)) prefixes.add(shardOf(h));
+    await Promise.all([...prefixes].map((p) => this.shard(p)));
+  }
+  /** Synchronous lookup; the shard must have been loaded (see preload / getAsync). */
+  entry(hash) {
+    return this.shards.get(shardOf(hash))?.[hash];
+  }
+  has(hash, id) {
+    if (this.transient.get(hash)?.[id] !== void 0) return true;
+    const e = this.entry(hash);
+    return !!e && e[id] !== void 0;
+  }
+  /** Synchronous lookup when the shard is already loaded; `undefined` otherwise (or when absent). */
+  peek(hash, id) {
+    const t = this.transient.get(hash)?.[id];
+    if (t !== void 0) return t;
+    return this.shards.get(shardOf(hash))?.[hash]?.[id];
+  }
+  async get(hash, id) {
+    const t = this.transient.get(hash)?.[id];
+    if (t !== void 0) return t;
+    if (!isContentHash(hash)) return void 0;
+    const s = await this.shard(shardOf(hash));
+    return s[hash]?.[id];
+  }
+  /**
+   * Store a fact. Values are normalized through JSON so a value read back from disk
+   * is indistinguishable from a freshly computed one.
+   */
+  async set(hash, id, value, opts = {}) {
+    const normalized = value === void 0 ? null : JSON.parse(JSON.stringify(value));
+    if (opts.persist === false || !isContentHash(hash)) {
+      const e2 = this.transient.get(hash) ?? {};
+      e2[id] = normalized;
+      this.transient.set(hash, e2);
+      return;
+    }
+    const prefix = shardOf(hash);
+    const s = await this.shard(prefix);
+    const e = s[hash] ??= {};
+    if (opts.replacePrefix) {
+      for (const k of Object.keys(e)) if (k !== id && k.startsWith(opts.replacePrefix)) delete e[k];
+    }
+    e[id] = normalized;
+    this.dirty.add(prefix);
+  }
+  /**
+   * Persist changed shards under `athenaDir` (default: where the cache was opened).
+   * With `live`, entries for content no longer present in the project are dropped
+   * from every loaded shard.
+   */
+  async save(athenaDir2, live) {
+    const dir = cacheRoot(athenaDir2);
+    const factsDir = path2.join(dir, FACTS_DIR);
+    const retarget = this.dir !== dir;
+    if (this.reset || retarget) {
+      await fs.rm(factsDir, { recursive: true, force: true });
+      for (const p of this.shards.keys()) this.dirty.add(p);
+    }
+    if (live) {
+      for (const [prefix, shard] of this.shards) {
+        for (const h of Object.keys(shard)) {
+          if (!live.has(h)) {
+            delete shard[h];
+            this.dirty.add(prefix);
+          }
+        }
+      }
+    }
+    await fs.mkdir(factsDir, { recursive: true });
+    const writes = [...this.dirty].map(async (prefix) => {
+      const shard = this.shards.get(prefix) ?? {};
+      const file = path2.join(factsDir, `${prefix}.json`);
+      if (!Object.keys(shard).length) await fs.rm(file, { force: true });
+      else await writeFileAtomic(file, JSON.stringify(shard));
+      this.stats.shardsWritten++;
+    });
+    await Promise.all(writes);
+    if (this.reset || retarget || writes.length) {
+      await writeFileAtomic(path2.join(factsDir, VERSION_FILE), JSON.stringify({ format: FACTS_FORMAT, ...this.identity }));
+    }
+    if (live) {
+      const livePrefixes = new Set([...live].filter(isContentHash).map(shardOf));
+      const names = await fs.readdir(factsDir).catch(() => []);
+      await Promise.all(names.filter((n) => /^[0-9a-f]{2}\.json$/.test(n) && !livePrefixes.has(n.slice(0, 2)) && !this.shards.has(n.slice(0, 2))).map((n) => fs.rm(path2.join(factsDir, n), { force: true })));
+    }
+    this.dirty.clear();
+    this.reset = false;
+    this.dir = dir;
+  }
+};
+function isContentHash(h) {
+  return h.length >= 16 && h.length <= 64 && !h.startsWith("meta:");
+}
+
+// src/core/state/state.ts
+import { promises as fs2 } from "fs";
+import path3 from "path";
+import { z as z2 } from "zod";
+var STATE_SCHEMA_VERSION = 2;
+var DocumentState = z2.object({
+  file: z2.string(),
+  blocks: z2.array(z2.string()),
+  lastGeneratedAt: z2.string(),
+  /** When the file content last changed due to Athena. */
+  lastChangedAt: z2.string(),
+  contentHash: z2.string(),
+  preservedModified: z2.array(z2.string())
+});
+var AgentState = z2.object({
+  configured: z2.boolean(),
+  files: z2.array(z2.string()),
+  configuredAt: z2.string().optional()
+});
+var StateFields = {
+  athenaVersion: z2.string(),
+  projectName: z2.string(),
+  createdAt: z2.string(),
+  analyzedAt: z2.string(),
+  analysisDurationMs: z2.number(),
+  git: z2.object({ isRepo: z2.boolean(), head: z2.string().optional(), branch: z2.string().optional() }),
+  documents: z2.record(z2.string(), DocumentState),
+  detectors: z2.record(z2.string(), z2.number()),
+  agents: z2.record(z2.string(), AgentState),
+  warnings: z2.array(z2.string())
+};
+var AthenaStateSchema = z2.object({ schemaVersion: z2.literal(STATE_SCHEMA_VERSION), ...StateFields });
+var AthenaStateV1 = z2.object({ schemaVersion: z2.literal(1), ...StateFields, fileIndex: z2.record(z2.string(), z2.unknown()) });
+var MAX_STATE_WARNINGS = 100;
+function athenaDir(root) {
+  return path3.join(root, ATHENA_DIR);
+}
+function fileIndexPath(dir) {
+  return path3.join(dir, CACHE_DIR, "files.json");
+}
+var stampOf = (st) => `${st.ino}:${st.size}:${st.mtimeMs}`;
+var stateMemo = /* @__PURE__ */ new Map();
+var indexMemo = /* @__PURE__ */ new Map();
+var pendingV1Index = /* @__PURE__ */ new Map();
+function isIndexEntry(v) {
+  if (!v || typeof v !== "object") return false;
+  const e = v;
+  return typeof e.h === "string" && typeof e.s === "number" && typeof e.m === "number" && (e.b === void 0 || e.b === 1);
+}
+async function readState(dir) {
+  const file = path3.join(dir, "state.json");
+  let st;
+  try {
+    st = await fs2.stat(file);
+  } catch (err) {
+    if (err.code === "ENOENT") return { kind: "missing" };
+    return { kind: "corrupted", reason: `unreadable (${err.code})` };
+  }
+  const memo = stateMemo.get(file);
+  if (memo && memo.stamp === stampOf(st)) return structuredClone(memo.result);
+  let raw;
+  try {
+    raw = await fs2.readFile(file, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return { kind: "missing" };
+    return { kind: "corrupted", reason: `unreadable (${err.code})` };
+  }
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    return { kind: "corrupted", reason: "invalid JSON" };
+  }
+  let result;
+  if (json && typeof json === "object" && json.schemaVersion === 1) {
+    result = await migrateV1(dir, json);
+    st = await fs2.stat(file).catch(() => st);
+  } else {
+    const parsed = AthenaStateSchema.safeParse(json);
+    if (!parsed.success) {
+      const issue = parsed.error.issues[0];
+      result = { kind: "corrupted", reason: `schema mismatch at ${issue?.path.join(".") || "(root)"}: ${issue?.message}` };
+    } else result = { kind: "ok", state: parsed.data };
+  }
+  stateMemo.set(file, { stamp: stampOf(st), result: structuredClone(result) });
+  return result;
+}
+async function migrateV1(dir, json) {
+  const parsed = AthenaStateV1.safeParse(json);
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0];
+    return { kind: "corrupted", reason: `schema mismatch at ${issue?.path.join(".") || "(root)"}: ${issue?.message}` };
+  }
+  const { fileIndex: rawIndex, schemaVersion: _v, ...rest } = parsed.data;
+  const index = {};
+  for (const [p, v] of Object.entries(rawIndex)) {
+    if (!isIndexEntry(v)) return { kind: "corrupted", reason: `schema mismatch at fileIndex.${p}: invalid entry` };
+    index[p] = v;
+  }
+  const state = { schemaVersion: STATE_SCHEMA_VERSION, ...rest };
+  try {
+    await writeFileIndex(dir, index);
+    await writeStateFile(dir, state);
+    pendingV1Index.delete(dir);
+  } catch {
+    pendingV1Index.set(dir, index);
+  }
+  return { kind: "ok", state };
+}
+async function writeStateFile(dir, state) {
+  const { fileIndex: _index, ...rest } = state;
+  const out = { ...rest, schemaVersion: STATE_SCHEMA_VERSION, warnings: rest.warnings.slice(0, MAX_STATE_WARNINGS) };
+  await writeFileAtomic(path3.join(dir, "state.json"), `${JSON.stringify(out, null, 2)}
+`);
+  stateMemo.delete(path3.join(dir, "state.json"));
+}
+async function writeState(dir, state) {
+  if (state.fileIndex) await writeFileIndex(dir, state.fileIndex);
+  await writeStateFile(dir, state);
+}
+async function readFileIndex(dir) {
+  const file = fileIndexPath(dir);
+  let st;
+  try {
+    st = await fs2.stat(file);
+  } catch {
+    const pending = pendingV1Index.get(dir);
+    if (pending) return pending;
+    const s = await readState(dir);
+    return s.kind === "ok" ? pendingV1Index.get(dir) ?? await readIndexFile(file) : {};
+  }
+  const memo = indexMemo.get(file);
+  if (memo && memo.stamp === stampOf(st)) return memo.index;
+  const index = await readIndexFile(file);
+  indexMemo.set(file, { stamp: stampOf(st), index });
+  return index;
+}
+async function readIndexFile(file) {
+  let json;
+  try {
+    json = JSON.parse(await fs2.readFile(file, "utf8"));
+  } catch {
+    return {};
+  }
+  const out = {};
+  const files = json?.files;
+  if (json?.v !== 1 || !files || typeof files !== "object") return out;
+  for (const [p, t] of Object.entries(files)) {
+    if (!Array.isArray(t) || typeof t[0] !== "string" || typeof t[1] !== "number" || typeof t[2] !== "number") continue;
+    out[p] = t[3] === 1 ? { h: t[0], s: t[1], m: t[2], b: 1 } : { h: t[0], s: t[1], m: t[2] };
+  }
+  return out;
+}
+var RACY_WINDOW_MS = 2e3;
+async function writeFileIndex(dir, index, now = Date.now()) {
+  const files = {};
+  for (const [p, e] of Object.entries(index)) {
+    const m = now - e.m < RACY_WINDOW_MS ? -1 : e.m;
+    files[p] = e.b === 1 ? [e.h, e.s, m, 1] : [e.h, e.s, m];
+  }
+  const file = fileIndexPath(dir);
+  await writeFileAtomic(file, JSON.stringify({ v: 1, files }));
+  indexMemo.delete(file);
+}
+async function backupCorruptedState(dir) {
+  const src = path3.join(dir, "state.json");
+  const backupDir = path3.join(dir, ".backup");
+  const dest = path3.join(backupDir, `state.${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.json`);
+  try {
+    await fs2.mkdir(backupDir, { recursive: true });
+    await fs2.rename(src, dest);
+    stateMemo.delete(src);
+    return dest;
+  } catch {
+    return null;
+  }
+}
+function buildFileIndex(files) {
+  const idx = {};
+  for (const f of files) idx[f.path] = { h: f.hash, s: f.size, m: f.mtimeMs, ...f.binary ? { b: 1 } : {} };
+  return idx;
+}
+function sameHash(a, b) {
+  if (a === b) return true;
+  if (a.startsWith("meta:") || b.startsWith("meta:")) return false;
+  const n = Math.min(a.length, b.length);
+  return n >= 16 && a.slice(0, n) === b.slice(0, n);
+}
+function diffFileIndex(prev, next) {
+  const diff = { added: [], modified: [], deleted: [] };
+  for (const [p, v] of Object.entries(next)) {
+    const old = prev[p];
+    if (!old) diff.added.push(p);
+    else if (!sameHash(old.h, v.h)) diff.modified.push(p);
+  }
+  for (const p of Object.keys(prev)) if (!(p in next)) diff.deleted.push(p);
+  return diff;
+}
+
+export {
+  DEFAULT_IGNORES,
+  loadConfig,
+  CACHE_DIR,
+  cacheRoot,
+  FactsCache,
+  STATE_SCHEMA_VERSION,
+  athenaDir,
+  fileIndexPath,
+  readState,
+  writeState,
+  readFileIndex,
+  RACY_WINDOW_MS,
+  backupCorruptedState,
+  buildFileIndex,
+  sameHash,
+  diffFileIndex
+};
+//# sourceMappingURL=chunk-2DY4PUR4.js.map

package/dist/chunk-2R6PXY6Z.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+// src/services/version.ts
+import { createRequire } from "module";
+var PACKAGE_NAME = "project-athena";
+var AUTHOR = "Sabarivasan";
+var NPM_URL = `https://www.npmjs.com/package/${PACKAGE_NAME}`;
+var REPO_URL = "https://github.com/Sabari-Vasan-SM/athena";
+var WEBSITE_URL = "https://athena.sabari.me";
+function readVersion() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    for (const p of ["../package.json", "../../package.json"]) {
+      try {
+        const pkg = require2(p);
+        if (pkg.name === PACKAGE_NAME && pkg.version) return pkg.version;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return "0.0.0-unknown";
+}
+var ATHENA_VERSION = readVersion();
+
+export {
+  AUTHOR,
+  NPM_URL,
+  REPO_URL,
+  WEBSITE_URL,
+  ATHENA_VERSION
+};
+//# sourceMappingURL=chunk-2R6PXY6Z.js.map