@agentprojectcontext/apx 1.0.3

package/src/core/parser.js

@@ -0,0 +1,217 @@
+// Core parsers for APC — pure ESM, no deps.
+import fs from "node:fs";
+import path from "node:path";
+
+export const SLUG_RE = /^[a-z][a-z0-9_-]*$/;
+const H1_RE = /^#\s+Agents\s*$/i;
+const H2_RE = /^##\s+(\S.*?)\s*$/;
+const FIELD_RE = /^-\s+\*\*([^*]+?)\*\*\s*:\s*(.*)$/;
+const INDENT_CONT_RE = /^\s{2,}\S/;
+const LIST_FIELDS = new Set(["Skills", "Tools"]);
+
+// ---------------------------------------------------------------------------
+// AGENTS.md parser (legacy / Codex compat source)
+// ---------------------------------------------------------------------------
+
+export function parseAgentsMd(text) {
+  const stripped = text.replace(/<!--[\s\S]*?-->/g, "");
+  const lines = stripped.split(/\r?\n/);
+  const agents = [];
+  let current = null;
+  let pendingField = null;
+  let seenH1 = false;
+
+  for (const raw of lines) {
+    const line = raw.replace(/\s+$/, "");
+    if (H1_RE.test(line)) { seenH1 = true; continue; }
+    const mH2 = line.match(H2_RE);
+    if (mH2 && seenH1) {
+      const slug = mH2[1].trim();
+      if (SLUG_RE.test(slug)) {
+        current = { slug, fields: {} };
+        agents.push(current);
+        pendingField = null;
+      } else {
+        current = null; pendingField = null;
+      }
+      continue;
+    }
+    if (!current) continue;
+    const mField = line.match(FIELD_RE);
+    if (mField) {
+      const name = mField[1].trim();
+      const value = mField[2].trim();
+      current.fields[name] = LIST_FIELDS.has(name)
+        ? value.split(",").map((s) => s.trim()).filter(Boolean)
+        : value;
+      pendingField = name;
+      continue;
+    }
+    if (pendingField && INDENT_CONT_RE.test(raw)) {
+      const existing = current.fields[pendingField];
+      if (!Array.isArray(existing)) {
+        current.fields[pendingField] = existing ? `${existing} ${raw.trim()}` : raw.trim();
+      }
+      continue;
+    }
+    if (line.trim() === "") pendingField = null;
+  }
+  return agents;
+}
+
+// ---------------------------------------------------------------------------
+// Per-agent file parser  (.apc/agents/<slug>.md)
+// ---------------------------------------------------------------------------
+
+export function parseAgentFile(slug, text) {
+  // Extract frontmatter
+  const fm = parseSessionFrontmatter(text);
+
+  // Body = everything after the closing ---
+  let body = "";
+  if (text.startsWith("---\n")) {
+    const end = text.indexOf("\n---\n", 4);
+    if (end !== -1) body = text.slice(end + 5).trim();
+  } else {
+    body = text.trim();
+  }
+
+  // Normalize keys to Title-case to stay consistent with AGENTS.md output
+  const fields = {};
+  for (const [k, v] of Object.entries(fm)) {
+    if (k === "slug") continue;
+    const key = k.charAt(0).toUpperCase() + k.slice(1);
+    fields[key] = LIST_FIELDS.has(key)
+      ? String(v).split(",").map((s) => s.trim()).filter(Boolean)
+      : v;
+  }
+
+  return { slug, fields, body };
+}
+
+// Read all .apc/agents/<slug>.md files. Returns [] if none exist.
+export function readAgentsFromDir(root) {
+  const dir = path.join(root, ".apc", "agents");
+  if (!fs.existsSync(dir)) return [];
+  return fs
+    .readdirSync(dir)
+    .filter((f) => f.endsWith(".md") && SLUG_RE.test(f.slice(0, -3)))
+    .sort()
+    .map((f) => {
+      const slug = f.slice(0, -3);
+      return parseAgentFile(slug, fs.readFileSync(path.join(dir, f), "utf8"));
+    });
+}
+
+// ---------------------------------------------------------------------------
+// Vault — ~/.apx/agents/<slug>.md  (global templates, no memory)
+// ---------------------------------------------------------------------------
+
+import os from "node:os";
+
+export const VAULT_DIR = path.join(os.homedir(), ".apx", "agents");
+
+export function readVaultAgents() {
+  if (!fs.existsSync(VAULT_DIR)) return [];
+  return fs
+    .readdirSync(VAULT_DIR)
+    .filter((f) => f.endsWith(".md") && SLUG_RE.test(f.slice(0, -3)))
+    .sort()
+    .map((f) => {
+      const slug = f.slice(0, -3);
+      const agent = parseAgentFile(slug, fs.readFileSync(path.join(VAULT_DIR, f), "utf8"));
+      return { ...agent, source: "vault" };
+    });
+}
+
+// Resolve a single agent for a project: local file → vault → null
+export function resolveAgent(root, slug) {
+  const localPath = path.join(root, ".apc", "agents", `${slug}.md`);
+  if (fs.existsSync(localPath)) {
+    const agent = parseAgentFile(slug, fs.readFileSync(localPath, "utf8"));
+    return { ...agent, source: "local" };
+  }
+  const vaultPath = path.join(VAULT_DIR, `${slug}.md`);
+  if (fs.existsSync(vaultPath)) {
+    const agent = parseAgentFile(slug, fs.readFileSync(vaultPath, "utf8"));
+    return { ...agent, source: "vault" };
+  }
+  return null;
+}
+
+// Return slugs imported from vault in this project (from project.json)
+export function importedVaultSlugs(root) {
+  const p = path.join(root, ".apc", "project.json");
+  if (!fs.existsSync(p)) return [];
+  try {
+    const cfg = JSON.parse(fs.readFileSync(p, "utf8"));
+    return cfg.agents?.imported ?? [];
+  } catch { return []; }
+}
+
+// Primary entry point.
+// Resolution order:
+//   1. .apc/agents/<slug>.md  (local — overrides everything)
+//   2. ~/.apx/agents/<slug>.md  (vault — for imported slugs)
+//   3. Legacy hand-written AGENTS.md (not auto-generated)
+export function readAgents(root) {
+  const fromFiles = readAgentsFromDir(root).map((a) => ({ ...a, source: "local" }));
+  const localSlugs = new Set(fromFiles.map((a) => a.slug));
+
+  // Vault agents imported into this project
+  const imported = importedVaultSlugs(root);
+  const vaultAgents = imported
+    .filter((slug) => !localSlugs.has(slug))
+    .map((slug) => {
+      const vaultPath = path.join(VAULT_DIR, `${slug}.md`);
+      if (!fs.existsSync(vaultPath)) return null;
+      const agent = parseAgentFile(slug, fs.readFileSync(vaultPath, "utf8"));
+      return { ...agent, source: "vault" };
+    })
+    .filter(Boolean);
+
+  const all = [...fromFiles, ...vaultAgents];
+  const allSlugs = new Set(all.map((a) => a.slug));
+
+  const agentsMdPath = path.join(root, "AGENTS.md");
+  if (!fs.existsSync(agentsMdPath)) return all;
+
+  const mdText = fs.readFileSync(agentsMdPath, "utf8");
+  if (mdText.includes("Auto-generated from .apc/agents/")) return all;
+
+  // Legacy hand-written AGENTS.md
+  const legacy = parseAgentsMd(mdText)
+    .filter((a) => !allSlugs.has(a.slug))
+    .map((a) => ({ ...a, source: "legacy" }));
+  return [...all, ...legacy];
+}
+
+// ---------------------------------------------------------------------------
+// Project root detection
+// ---------------------------------------------------------------------------
+
+export function findApfRoot(start = process.cwd()) {
+  let cur = path.resolve(start);
+  while (true) {
+    if (fs.existsSync(path.join(cur, ".apc", "project.json"))) return cur;
+    const parent = path.dirname(cur);
+    if (parent === cur) return null;
+    cur = parent;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Session / conversation frontmatter
+// ---------------------------------------------------------------------------
+
+export function parseSessionFrontmatter(text) {
+  if (!text.startsWith("---\n")) return {};
+  const end = text.indexOf("\n---", 4);
+  if (end === -1) return {};
+  const out = {};
+  for (const line of text.slice(4, end).split("\n")) {
+    const m = line.match(/^([a-zA-Z_-]+):\s*(.*)$/);
+    if (m) out[m[1]] = m[2].trim();
+  }
+  return out;
+}

package/src/core/routines-store.js

@@ -0,0 +1,144 @@
+// File-based routines store: read/write .apc/routines.json.
+// Replaces the SQLite `routines` table for project-scoped scheduled tasks.
+import fs from "node:fs";
+import path from "node:path";
+
+const nowIso = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
+const isoToMs = (iso) => (iso ? Date.parse(iso) : 0);
+
+function routinesPath(projectPath) {
+  return path.join(projectPath, ".apc", "routines.json");
+}
+
+function readFile(projectPath) {
+  const p = routinesPath(projectPath);
+  if (!fs.existsSync(p)) return [];
+  try {
+    const raw = JSON.parse(fs.readFileSync(p, "utf8"));
+    return Array.isArray(raw.routines) ? raw.routines : [];
+  } catch {
+    return [];
+  }
+}
+
+function writeFile(projectPath, routines) {
+  const p = routinesPath(projectPath);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, JSON.stringify({ routines }, null, 2) + "\n");
+}
+
+// --------------------- schedule parsing -------------------------------------
+
+export function parseSchedule(s, baseMs = Date.now()) {
+  if (!s || typeof s !== "string") return { kind: "invalid" };
+  if (s.startsWith("every:")) {
+    const spec = s.slice(6).trim();
+    const m = spec.match(/^(\d+)(s|m|h|d)$/);
+    if (!m) return { kind: "invalid" };
+    const n = parseInt(m[1], 10);
+    const mult = { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 }[m[2]];
+    return { kind: "every", intervalMs: n * mult };
+  }
+  if (s.startsWith("once:")) {
+    const ts = s.slice(5).trim();
+    const ms = Date.parse(ts);
+    if (isNaN(ms)) return { kind: "invalid" };
+    return { kind: "once", atMs: ms };
+  }
+  return { kind: "invalid" };
+}
+
+export function computeNextRun(routine, baseMs = Date.now()) {
+  const sched = parseSchedule(routine.schedule, baseMs);
+  if (sched.kind === "invalid") return null;
+  if (sched.kind === "once") {
+    return sched.atMs > baseMs
+      ? new Date(sched.atMs).toISOString().replace(/\.\d{3}Z$/, "Z")
+      : null;
+  }
+  if (sched.kind === "every") {
+    const last = isoToMs(routine.last_run_at);
+    const next = (last || baseMs) + sched.intervalMs;
+    const target = next < baseMs ? baseMs + 100 : next;
+    return new Date(target).toISOString().replace(/\.\d{3}Z$/, "Z");
+  }
+  return null;
+}
+
+// --------------------- CRUD -------------------------------------------------
+
+export function listRoutines(projectPath) {
+  return readFile(projectPath);
+}
+
+export function getRoutine(projectPath, name) {
+  return readFile(projectPath).find((r) => r.name === name) || null;
+}
+
+export function upsertRoutine(projectPath, { name, kind, schedule, spec, enabled = true }) {
+  if (!name || !kind || !schedule) throw new Error("routine requires name, kind, schedule");
+  const now = nowIso();
+  const routines = readFile(projectPath);
+  const idx = routines.findIndex((r) => r.name === name);
+  const prev = idx >= 0 ? routines[idx] : null;
+  const next = computeNextRun({ schedule, last_run_at: null });
+  const entry = {
+    name,
+    kind,
+    schedule,
+    spec: spec || {},
+    enabled: enabled !== false,
+    last_run_at: prev?.last_run_at ?? null,
+    last_status: prev?.last_status ?? null,
+    last_error: prev?.last_error ?? null,
+    next_run_at: next,
+    created_at: prev?.created_at ?? now,
+    updated_at: now,
+  };
+  if (idx >= 0) {
+    routines[idx] = entry;
+  } else {
+    routines.push(entry);
+  }
+  writeFile(projectPath, routines);
+  return entry;
+}
+
+export function deleteRoutine(projectPath, name) {
+  const routines = readFile(projectPath);
+  const idx = routines.findIndex((r) => r.name === name);
+  if (idx === -1) return false;
+  routines.splice(idx, 1);
+  writeFile(projectPath, routines);
+  return true;
+}
+
+export function setEnabled(projectPath, name, enabled) {
+  const routines = readFile(projectPath);
+  const r = routines.find((x) => x.name === name);
+  if (!r) return false;
+  r.enabled = !!enabled;
+  r.updated_at = nowIso();
+  writeFile(projectPath, routines);
+  return true;
+}
+
+export function updateRunState(projectPath, name, { last_run_at, last_status, last_error, next_run_at, disable = false }) {
+  const routines = readFile(projectPath);
+  const r = routines.find((x) => x.name === name);
+  if (!r) return false;
+  r.last_run_at = last_run_at;
+  r.last_status = last_status;
+  r.last_error = last_error || null;
+  r.next_run_at = next_run_at;
+  r.updated_at = last_run_at || nowIso();
+  if (disable) r.enabled = false;
+  writeFile(projectPath, routines);
+  return true;
+}
+
+export function getDueRoutines(projectPath, nowStr) {
+  return readFile(projectPath).filter(
+    (r) => r.enabled && (!r.next_run_at || r.next_run_at <= nowStr)
+  );
+}