@iiwish/agentrecord 0.0.1

package/scripts/smoke-install.mjs

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+
+import { mkdirSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const tempRoot = mkdtempSync(path.join(tmpdir(), "agentrecord-smoke-"));
+const packDir = path.join(tempRoot, "pack");
+const installDir = path.join(tempRoot, "install");
+const expectedVersion = JSON.parse(readFileSync(path.join(repoRoot, "package.json"), "utf8")).version;
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd || repoRoot,
+    encoding: "utf8",
+    shell: false,
+    env: {
+      ...process.env,
+      npm_config_update_notifier: "false",
+      npm_config_fund: "false",
+      npm_config_audit: "false"
+    }
+  });
+
+  if (result.status !== 0) {
+    const stderr = result.stderr ? `\n${result.stderr.trim()}` : "";
+    const stdout = result.stdout ? `\n${result.stdout.trim()}` : "";
+    throw new Error(`${command} ${args.join(" ")} failed with exit ${result.status}${stdout}${stderr}`);
+  }
+
+  return result.stdout;
+}
+
+function assertEqual(actual, expected, label) {
+  if (actual.trim() !== expected) {
+    throw new Error(`${label} expected ${JSON.stringify(expected)} but received ${JSON.stringify(actual.trim())}`);
+  }
+}
+
+try {
+  mkdirSync(packDir, { recursive: true });
+  mkdirSync(installDir, { recursive: true });
+  const packOutput = run("npm", ["pack", "--json", "--pack-destination", packDir]);
+  const packInfo = JSON.parse(packOutput)[0];
+  const tarball = path.join(packDir, packInfo.filename);
+
+  run("npm", ["install", "--ignore-scripts", tarball], { cwd: installDir });
+
+  const bin = path.join(installDir, "node_modules", ".bin", process.platform === "win32" ? "agentrecord.cmd" : "agentrecord");
+
+  assertEqual(run(bin, ["--version"], { cwd: installDir }), expectedVersion, "agentrecord --version");
+  assertEqual(run(bin, ["version"], { cwd: installDir }), expectedVersion, "agentrecord version");
+
+  run(bin, ["init", "--dry-run", "--owner", "smoke-owner"], { cwd: installDir });
+  run(bin, ["doctor"], { cwd: installDir });
+
+  console.log(JSON.stringify({
+    ok: true,
+    temp_dir: tempRoot,
+    tarball: packInfo.filename,
+    version: expectedVersion,
+    commands: [
+      "agentrecord --version",
+      "agentrecord version",
+      "agentrecord init --dry-run --owner smoke-owner",
+      "agentrecord doctor"
+    ]
+  }, null, 2));
+} finally {
+  if (process.env.AGENTRECORD_KEEP_SMOKE_TEMP !== "1") {
+    rmSync(tempRoot, { recursive: true, force: true });
+  }
+}

package/src/build/artifacts.mjs

@@ -0,0 +1,29 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { renderAgentContextJson, renderAgentContextMarkdown, renderHtml, renderMarkdown, renderRedactionReport, renderRunReport } from "./renderers.mjs";
+
+export function writeArtifacts({ config, profile, evidenceCards, localeBundle, privateState, agentContextEnabled }) {
+  const outDir = config.resolved.profileDir;
+  fs.writeFileSync(path.join(outDir, "profile.json"), `${JSON.stringify(profile, null, 2)}\n`);
+  fs.writeFileSync(path.join(outDir, "evidence.jsonl"), `${evidenceCards.map((card) => JSON.stringify(card)).join("\n")}\n`);
+  fs.writeFileSync(path.join(outDir, "profile.md"), renderMarkdown(profile, localeBundle));
+  fs.writeFileSync(path.join(outDir, "index.html"), renderHtml(profile, localeBundle));
+  fs.writeFileSync(path.join(outDir, "redaction-report.md"), renderRedactionReport(profile, localeBundle));
+  fs.writeFileSync(path.join(outDir, "run-report.md"), renderRunReport(profile, localeBundle));
+  if (agentContextEnabled) {
+    fs.writeFileSync(path.join(outDir, "agent-context.md"), renderAgentContextMarkdown(profile, localeBundle));
+    fs.writeFileSync(path.join(outDir, "agent-context.json"), `${JSON.stringify(renderAgentContextJson(profile), null, 2)}\n`);
+  } else {
+    removeGeneratedArtifactIfExists(outDir, "agent-context.md");
+    removeGeneratedArtifactIfExists(outDir, "agent-context.json");
+  }
+  fs.writeFileSync(path.join(config.resolved.privateStateDir, "state.json"), `${JSON.stringify(privateState, null, 2)}\n`);
+  removeGeneratedArtifactIfExists(outDir, "hiring.html");
+  removeGeneratedArtifactIfExists(outDir, "job-agent-profile.md");
+}
+
+function removeGeneratedArtifactIfExists(outDir, file) {
+  const target = path.join(outDir, file);
+  if (fs.existsSync(target)) fs.rmSync(target);
+}

package/src/build/catalog.mjs

@@ -0,0 +1,33 @@
+
+const supportedLocales = ["en-US", "zh-CN"];
+
+const dimensions = [
+  { id: "goal_framing", canonical: "Goal Framing" },
+  { id: "context_packaging", canonical: "Context Packaging" },
+  { id: "agent_delegation", canonical: "Agent Delegation" },
+  { id: "review_judgment", canonical: "Review Judgment" },
+  { id: "verification_discipline", canonical: "Verification Discipline" },
+  { id: "failure_recovery", canonical: "Failure Recovery" },
+  { id: "scope_control", canonical: "Scope Control" },
+  { id: "shipping_hygiene", canonical: "Shipping Hygiene" },
+  { id: "product_judgment", canonical: "Product Judgment" },
+  { id: "collaboration_handoff", canonical: "Collaboration Handoff" }
+];
+
+const roles = [
+  { id: "product_builder", canonical: "Product Builder" },
+  { id: "technical_reviewer", canonical: "Technical Reviewer" },
+  { id: "agent_operator", canonical: "Agent Operator" },
+  { id: "shipping_owner", canonical: "Shipping Owner" },
+  { id: "systems_thinker", canonical: "Systems Thinker" },
+  { id: "research_synthesizer", canonical: "Research Synthesizer" },
+  { id: "collaboration_handoff", canonical: "Collaboration Handoff" }
+];
+
+const dimensionByCanonical = new Map(dimensions.map((item) => [item.canonical.toLowerCase(), item.id]));
+const roleByCanonical = new Map(roles.map((item) => [item.canonical.toLowerCase(), item.id]));
+roleByCanonical.set("delivery owner", "shipping_owner");
+roleByCanonical.set("ai agent operator", "agent_operator");
+roleByCanonical.set("software engineer", "systems_thinker");
+
+export { supportedLocales, dimensions, roles, dimensionByCanonical, roleByCanonical };

package/src/build/codex-account.mjs

@@ -0,0 +1,183 @@
+import { spawn } from "node:child_process";
+
+const DEFAULT_TIMEOUT_MS = 15000;
+
+export async function readCodexAccountUsage(options = {}) {
+  const enabled = options.enabled !== false;
+  if (!enabled) {
+    return {
+      status: "disabled",
+      source: "codex_app_server",
+      summary: null,
+      daily_usage_buckets: null
+    };
+  }
+
+  const executable = options.executable || "codex";
+  const timeoutMs = Number.isFinite(Number(options.timeoutMs))
+    ? Math.max(1000, Number(options.timeoutMs))
+    : DEFAULT_TIMEOUT_MS;
+
+  try {
+    const result = await callCodexAppServer({ executable, timeoutMs });
+    const usage = normalizeUsage(result.usage);
+    return {
+      status: usage.summary ? "measured" : "unavailable",
+      source: "codex_app_server",
+      source_label: "Codex CLI account usage",
+      account: normalizeAccount(result.account),
+      summary: usage.summary,
+      daily_usage_buckets: usage.daily_usage_buckets,
+      status_reason: usage.summary ? null : "account_usage_unavailable"
+    };
+  } catch (error) {
+    return {
+      status: "unavailable",
+      source: "codex_app_server",
+      source_label: "Codex CLI account usage",
+      account: null,
+      summary: null,
+      daily_usage_buckets: null,
+      status_reason: sanitizeReason(error)
+    };
+  }
+}
+
+function callCodexAppServer({ executable, timeoutMs }) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(executable, ["app-server"], {
+      stdio: ["pipe", "pipe", "ignore"]
+    });
+
+    let nextId = 1;
+    let buffer = "";
+    const pending = new Map();
+    const results = {};
+    let settled = false;
+
+    const finish = (error, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      child.kill("SIGTERM");
+      if (error) reject(error);
+      else resolve(value);
+    };
+
+    const timer = setTimeout(() => finish(new Error("timeout")), timeoutMs);
+
+    const send = (method, params, key) => {
+      const id = nextId;
+      nextId += 1;
+      pending.set(id, key);
+      const message = params === undefined ? { id, method } : { id, method, params };
+      child.stdin.write(`${JSON.stringify(message)}\n`);
+    };
+
+    const notify = (method, params = {}) => {
+      child.stdin.write(`${JSON.stringify({ method, params })}\n`);
+    };
+
+    const maybeDone = () => {
+      if (results.account !== undefined && results.usage !== undefined) {
+        finish(null, results);
+      }
+    };
+
+    child.on("error", (error) => finish(error));
+    child.on("exit", (code) => {
+      if (!settled && code !== 0) finish(new Error(`app_server_exit_${code}`));
+    });
+
+    child.stdout.on("data", (chunk) => {
+      buffer += chunk.toString("utf8");
+      let newlineIndex;
+      while ((newlineIndex = buffer.indexOf("\n")) !== -1) {
+        const line = buffer.slice(0, newlineIndex).trim();
+        buffer = buffer.slice(newlineIndex + 1);
+        if (!line) continue;
+        let message;
+        try {
+          message = JSON.parse(line);
+        } catch {
+          continue;
+        }
+
+        if (message.id == null) continue;
+        const key = pending.get(message.id);
+        if (!key) continue;
+
+        if (message.error) {
+          results[key] = { error: message.error };
+        } else {
+          results[key] = message.result || null;
+        }
+
+        if (key === "initialize") {
+          notify("initialized");
+          send("account/read", {}, "account");
+          send("account/usage/read", undefined, "usage");
+        }
+
+        maybeDone();
+      }
+    });
+
+    send("initialize", {
+      clientInfo: {
+        name: "agentrecord",
+        title: "AgentRecord",
+        version: "0.0.0"
+      },
+      capabilities: {
+        experimentalApi: true
+      }
+    }, "initialize");
+  });
+}
+
+function normalizeUsage(raw) {
+  if (!raw || raw.error) return { summary: null, daily_usage_buckets: null };
+  const sourceSummary = raw.summary || {};
+  const summary = {
+    lifetime_tokens: nullableNumber(sourceSummary.lifetimeTokens),
+    peak_daily_tokens: nullableNumber(sourceSummary.peakDailyTokens),
+    longest_running_turn_sec: nullableNumber(sourceSummary.longestRunningTurnSec),
+    current_streak_days: nullableNumber(sourceSummary.currentStreakDays),
+    longest_streak_days: nullableNumber(sourceSummary.longestStreakDays)
+  };
+  const hasSummary = Object.values(summary).some((value) => value !== null);
+  const dailyBuckets = Array.isArray(raw.dailyUsageBuckets)
+    ? raw.dailyUsageBuckets.map((bucket) => ({
+        start_date: String(bucket.startDate || ""),
+        tokens: nullableNumber(bucket.tokens) || 0
+      })).filter((bucket) => bucket.start_date)
+    : null;
+
+  return {
+    summary: hasSummary ? summary : null,
+    daily_usage_buckets: dailyBuckets
+  };
+}
+
+function normalizeAccount(raw) {
+  const account = raw?.account;
+  if (!account || raw.error) return null;
+  return {
+    type: account.type || null,
+    plan_type: account.planType || null,
+    email_included: false
+  };
+}
+
+function nullableNumber(value) {
+  return Number.isFinite(Number(value)) ? Number(value) : null;
+}
+
+function sanitizeReason(error) {
+  const message = String(error?.message || error || "unknown");
+  if (message === "timeout") return "timeout";
+  if (message.startsWith("app_server_exit_")) return message;
+  if (message.includes("ENOENT")) return "codex_not_found";
+  return "codex_app_server_unavailable";
+}

package/src/build/evidence.mjs

@@ -0,0 +1,143 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { readJsonIfExists } from "../core/config.mjs";
+import { dimensionByCanonical, roleByCanonical } from "./catalog.mjs";
+import { repoRoot } from "./paths.mjs";
+import { snakeId, unique } from "./utils.mjs";
+
+export function loadEvidenceRules(files) {
+  const rules = new Map();
+  for (const file of files) {
+    const parsed = readJsonIfExists(file) || readJsonIfExists(path.join(repoRoot, "references", path.basename(file)));
+    if (!Array.isArray(parsed?.rules)) continue;
+    for (const rule of parsed.rules) {
+      if (!rule?.id) continue;
+      rules.set(rule.id, {
+        ...rule,
+        rule_source_path: `references/${path.basename(file)}`,
+        rule_scope: parsed.scope || null
+      });
+    }
+  }
+  return [...rules.values()];
+}
+
+export function extractMemoryBlocks(file) {
+  if (!file || !fs.existsSync(file)) return [];
+  const lines = fs.readFileSync(file, "utf8").split(/\n/);
+  const starts = [];
+  lines.forEach((line, index) => {
+    if (/^# Task Group: /.test(line)) starts.push(index);
+  });
+
+  return starts.map((startIndex, position) => {
+    const endIndex = position + 1 < starts.length ? starts[position + 1] - 1 : lines.length - 1;
+    const bodyLines = lines.slice(startIndex, endIndex + 1);
+    return {
+      title: lines[startIndex].replace(/^# Task Group:\s*/, "").trim(),
+      body: bodyLines.join("\n"),
+      start_line: startIndex + 1,
+      end_line: endIndex + 1,
+      source: path.basename(file)
+    };
+  });
+}
+
+function matchesRule(block, rule) {
+  const text = `${block.title}\n${block.body}`.toLowerCase();
+  const includeAll = rule.match?.include_all || [];
+  const includeAny = rule.match?.include_any || [];
+  const excludeAny = rule.match?.exclude_any || [];
+  const allIncluded = includeAll.every((pattern) => text.includes(String(pattern).toLowerCase()));
+  const anyIncluded = includeAny.length === 0 || includeAny.some((pattern) => text.includes(String(pattern).toLowerCase()));
+  const excluded = excludeAny.some((pattern) => text.includes(String(pattern).toLowerCase()));
+  return allIncluded && anyIncluded && !excluded;
+}
+
+export function buildEvidenceCards({ stats, rules, memoryBlocks, locale }) {
+  const cards = [];
+
+  for (const rule of rules.filter((item) => !item.fallback)) {
+    const matches = memoryBlocks.filter((block) => matchesRule(block, rule));
+    if (!matches.length) continue;
+
+    cards.push({
+      id: rule.id,
+      level: rule.evidence_level || ["E3"],
+      title: rule.title,
+      category: rule.category,
+      summary: locale === "zh-CN"
+        ? `${rule.signal_template} 已匹配 ${matches.length} 个精选记忆任务组。`
+        : `${rule.signal_template} Matched ${matches.length} curated memory task group${matches.length === 1 ? "" : "s"}.`,
+      agent_clients: ["codex"],
+      dimensions: normalizeDimensionIds(rule.dimensions),
+      role_signals: normalizeRoleIds(rule.role_impacts),
+      confidence: confidenceFromLevels(rule.evidence_level),
+      refs: [
+        ...matches.slice(0, 4).map((block) => ({
+          type: "memory",
+          source: block.source,
+          start_line: block.start_line,
+          end_line: block.end_line
+        })),
+        { type: "metadata", source: "codex_session_metadata" }
+      ],
+      extraction: {
+        rule_id: rule.id,
+        rule_source_path: rule.rule_source_path,
+        rule_scope: rule.rule_scope
+      },
+      privacy: {
+        public_safe: true,
+        mode: "summary_only",
+        redacted_fields: ["raw prompts", "raw responses", "raw session ids", "terminal bodies", "source bodies"]
+      }
+    });
+  }
+
+  const fallbackRule = rules.find((rule) => rule.fallback);
+  if (fallbackRule && (cards.length === 0 || stats.files > 0)) {
+    cards.push({
+      id: fallbackRule.id,
+      level: fallbackRule.evidence_level || ["E2"],
+      title: fallbackRule.title,
+      category: fallbackRule.category,
+      summary: locale === "zh-CN"
+        ? `${fallbackRule.signal_template} 已扫描 ${stats.files} 个 Codex 本地会话，涉及 ${stats.top_projects.length} 个脱敏项目。`
+        : `${fallbackRule.signal_template} Scanned ${stats.files} Codex rollout files across ${stats.top_projects.length} redacted project references.`,
+      agent_clients: ["codex"],
+      dimensions: normalizeDimensionIds(fallbackRule.dimensions),
+      role_signals: normalizeRoleIds(fallbackRule.role_impacts),
+      confidence: stats.files > 0 ? "medium" : "low",
+      refs: [{ type: "metadata", source: "codex_session_metadata" }],
+      extraction: {
+        rule_id: fallbackRule.id,
+        rule_source_path: fallbackRule.rule_source_path,
+        rule_scope: fallbackRule.rule_scope
+      },
+      privacy: {
+        public_safe: true,
+        mode: "aggregate_only",
+        redacted_fields: ["raw session ids", "session file paths", "private project paths"]
+      }
+    });
+  }
+
+  return cards;
+}
+
+function normalizeDimensionIds(values = []) {
+  return unique(values.map((value) => dimensionByCanonical.get(String(value).toLowerCase()) || snakeId(value)));
+}
+
+function normalizeRoleIds(values = []) {
+  return unique(values.map((value) => roleByCanonical.get(String(value).toLowerCase()) || snakeId(value)));
+}
+
+function confidenceFromLevels(levels = []) {
+  if (levels.includes("E1") && levels.includes("E2")) return "high";
+  if (levels.includes("E1") || levels.includes("E2")) return "medium";
+  if (levels.includes("E3")) return "medium";
+  return "low";
+}

package/src/build/paths.mjs

@@ -0,0 +1,6 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export const repoRoot = path.resolve(__dirname, "..", "..");