getprismo 0.1.59 → 0.1.61

package/docs/manual.md

@@ -1055,6 +1055,15 @@ npx getprismo context backend
 
 use these as the starting point for coding sessions instead of letting agents explore the whole repo.
 
+Each generated context pack also gets a machine-readable receipt next to it, for example:
+
+```text
+.prismo/frontend-context.md
+.prismo/frontend-context.receipt.json
+```
+
+Receipts record the repo ref, intended agent surfaces, source roots, omitted context classes, a digest of the source-file slice, estimated pack tokens, stale-after policy, and the command to regenerate/verify the pack. They do not include raw prompts or source contents; the digest is an audit handle so later sessions and the dashboard can tell what a pack represents without treating it as opaque markdown.
+
 ---
 
 ## tracking modes
@@ -1081,8 +1090,13 @@ no api keys. no intercepted prompts. no data uploaded.
 ├── architecture-summary.md
 ├── backend-summary.md
 ├── frontend-summary.md
+├── architecture-summary.receipt.json
+├── backend-summary.receipt.json
+├── frontend-summary.receipt.json
 ├── frontend-context.md
+├── frontend-context.receipt.json
 ├── backend-context.md
+├── backend-context.receipt.json
 ├── recommended-CLAUDE.boilerplate.md
 ├── recommended-AGENTS.boilerplate.md
 ├── recommended-.claudeignore

package/lib/prismo-dev/cloud-sync.js

@@ -386,7 +386,9 @@ module.exports = function createCloudSync(deps) {
   }
 
   async function runSync(rootDir = process.cwd(), options = {}) {
-    const config = loadConfig();
+    // Allow an embedding host (the editor extension) to inject its own
+    // connection instead of reading the CLI's on-disk config.
+    const config = options.config || loadConfig();
     const payload = buildSyncPayload(rootDir, {
       limit: options.limit || config?.sync?.defaultLimit || 20,
       tool: options.tool || "all",

package/lib/prismo-dev/context-optimize.js

@@ -1,14 +1,17 @@
 module.exports = function createContextOptimize(deps) {
+  const crypto = require("crypto");
+  const { spawnSync } = require("child_process");
   const {
     fs,
     path,
     NPX_COMMAND,
+    PACKAGE_VERSION,
+    estimateTokens,
     scanRepo,
     safeReadJson,
     readIfText,
     formatBytes,
     color,
-    writeGeneratedFile,
   } = deps;
 
   const {
@@ -125,6 +128,145 @@ function proseList(items, empty = "none detected") {
   return items && items.length ? items.join(", ") : empty;
 }
 
+function sha256(value) {
+  return `sha256:${crypto.createHash("sha256").update(String(value)).digest("hex")}`;
+}
+
+function gitValue(root, args) {
+  try {
+    const result = spawnSync("git", args, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    return result.status === 0 ? result.stdout.trim() || null : null;
+  } catch {
+    return null;
+  }
+}
+
+function workingTreeDirty(root) {
+  try {
+    const result = spawnSync("git", ["status", "--porcelain"], { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    if (result.status !== 0) return null;
+    return result.stdout.trim().length > 0;
+  } catch {
+    return null;
+  }
+}
+
+function repoRef(root) {
+  const branch = gitValue(root, ["rev-parse", "--abbrev-ref", "HEAD"]);
+  const commit = gitValue(root, ["rev-parse", "--short=12", "HEAD"]);
+  // A pack derived from uncommitted files has a different staleness boundary
+  // than one derived from a clean commit, so record the working-tree state.
+  // null when this is not a git repo.
+  const inRepo = Boolean(branch || commit);
+  return {
+    branch,
+    commit,
+    working_tree_dirty: inRepo ? workingTreeDirty(root) : null,
+  };
+}
+
+// Directory roots that are intentionally kept out of context grounding (they
+// map to the receipt's omitted_classes). Used to separate roots that actually
+// grounded the pack from roots that were merely present and avoided.
+const EXCLUDED_ROOT_DIRS = new Set([
+  "node_modules", "vendor", ".venv", "venv",
+  "dist", "build", "out", "target", ".next", ".nuxt", ".output", ".svelte-kit",
+  "coverage", ".nyc_output",
+  "logs", "log",
+  ".cache", "__pycache__", ".git",
+]);
+
+function isExcludedRoot(root) {
+  return String(root || "").split("/").some((seg) => EXCLUDED_ROOT_DIRS.has(seg.toLowerCase()));
+}
+
+function isContextPackFile(name) {
+  return name === "architecture-summary.md" ||
+    name === "backend-summary.md" ||
+    name === "frontend-summary.md" ||
+    name.endsWith("-context.md");
+}
+
+function rootsFromPaths(paths) {
+  return Array.from(new Set((paths || [])
+    .map((p) => String(p || "").replace(/\\/g, "/").split("/").filter(Boolean).slice(0, 2).join("/"))
+    .filter(Boolean)))
+    .sort();
+}
+
+function sourceRootsForPack(ctx, name) {
+  if (name === "backend-summary.md") {
+    return rootsFromPaths([
+      ...ctx.backend.api,
+      ...ctx.backend.services,
+      ...ctx.backend.models,
+      ...ctx.backend.db,
+      ...ctx.backend.auth,
+      ...ctx.backend.config,
+    ]);
+  }
+  if (name === "frontend-summary.md") {
+    return rootsFromPaths([
+      ...ctx.frontend.app,
+      ...ctx.frontend.components,
+      ...ctx.frontend.apiClient,
+      ...ctx.frontend.state,
+      ...ctx.frontend.styling,
+    ]);
+  }
+  if (name.endsWith("-context.md")) {
+    return rootsFromPaths(scopedRelevantFiles(ctx, name.replace(/-context\.md$/, "")));
+  }
+  return ctx.folders.slice(0, 30);
+}
+
+function matchingSourceFiles(ctx, roots) {
+  if (!roots || !roots.length) return ctx.scan.files.slice(0, 250);
+  return ctx.scan.files.filter((file) => roots.some((root) => file.path === root || file.path.startsWith(`${root}/`)));
+}
+
+function renderPackReceipt(ctx, name, contents) {
+  const packPath = `.prismo/${name}`;
+  const packId = name.replace(/\.md$/, "");
+  const candidateRoots = sourceRootsForPack(ctx, name);
+  // Separate roots that actually grounded the pack from roots that were present
+  // but deliberately kept out (build output, logs, vendored deps). Without this,
+  // a later reader could assume the pack was grounded in e.g. dist/ or logs/.
+  const includedSourceRoots = candidateRoots.filter((root) => !isExcludedRoot(root));
+  const excludedRoots = candidateRoots.filter((root) => isExcludedRoot(root));
+  const sourceFiles = matchingSourceFiles(ctx, includedSourceRoots)
+    .filter((file) => file.kind !== "binary")
+    .map((file) => ({
+      path: file.path,
+      size: file.size,
+      kind: file.kind,
+      tokens: file.tokens,
+    }))
+    .sort((a, b) => a.path.localeCompare(b.path));
+  return JSON.stringify({
+    schema_version: 1,
+    pack_id: packId,
+    pack_path: packPath,
+    receipt_path: `.prismo/${packId}.receipt.json`,
+    generated_at: ctx.generatedAt,
+    prismo_version: PACKAGE_VERSION,
+    repo_ref: repoRef(ctx.root),
+    target_agents: ["claude-code", "cursor", "codex", "mcp"],
+    included_source_roots: includedSourceRoots,
+    excluded_roots: excludedRoots,
+    source_globs_digest: sha256(JSON.stringify({
+      pack_id: packId,
+      source_roots: includedSourceRoots,
+      files: sourceFiles,
+    })),
+    omitted_classes: ["lockfiles", "build-output", "large-logs", "coverage", "dependency-vendor", "binary-media"],
+    token_budget: 12000,
+    estimated_pack_tokens: estimateTokens(contents),
+    stale_if_older_than_ms: 86400000,
+    verify_command: `${NPX_COMMAND} optimize${ctx.scope ? ` ${ctx.scope}` : ""}`,
+  }, null, 2) + "\n";
+}
+
 function renderArchitectureSummary(ctx) {
   const apiLayer = ctx.backend.api.slice(0, 6);
   const dbLayer = ctx.backend.db.slice(0, 6);
@@ -429,9 +571,9 @@ function writeOptimizeGeneratedFile(root, relPath, contents) {
   return { path: relPath, backupPath: null, replaced: existed };
 }
 
-function renderScopedContext(ctx, scope) {
+function scopedRelevantFiles(ctx, scope) {
   const scopeLower = scope.toLowerCase();
-  const relevant = ctx.scan.files
+  return ctx.scan.files
     .filter((file) => {
       const rel = file.path.toLowerCase();
       if (scopeLower === "frontend") return rel.includes("frontend/") || rel.includes("src/app/") || rel.includes("src/components/");
@@ -442,6 +584,10 @@ function renderScopedContext(ctx, scope) {
     .filter((file) => file.kind !== "binary")
     .slice(0, 60)
     .map((file) => file.path);
+}
+
+function renderScopedContext(ctx, scope) {
+  const relevant = scopedRelevantFiles(ctx, scope);
 
   return [
     `# ${scope.charAt(0).toUpperCase()}${scope.slice(1)} Context`,
@@ -544,7 +690,11 @@ function runOptimize(rootDir = process.cwd(), options = {}) {
   const pending = getOptimizePendingFiles(ctx);
 
   if (options.dryRun) {
-    const generatedFiles = pending.map(([name]) => path.join(".prismo", name));
+    const generatedFiles = pending.flatMap(([name]) => {
+      const files = [path.join(".prismo", name)];
+      if (isContextPackFile(name)) files.push(path.join(".prismo", `${name.replace(/\.md$/, "")}.receipt.json`));
+      return files;
+    });
     generatedFiles.push(".prismo/optimize-report.md");
     return {
       root: ctx.root,
@@ -564,6 +714,12 @@ function runOptimize(rootDir = process.cwd(), options = {}) {
   for (const [name, contents] of pending) {
     const written = writeOptimizeGeneratedFile(ctx.root, path.join(".prismo", name), contents);
     generated.push(written.path);
+    if (isContextPackFile(name)) {
+      const receipt = renderPackReceipt(ctx, name, contents);
+      const receiptName = `${name.replace(/\.md$/, "")}.receipt.json`;
+      const writtenReceipt = writeOptimizeGeneratedFile(ctx.root, path.join(".prismo", receiptName), receipt);
+      generated.push(writtenReceipt.path);
+    }
   }
   const report = renderOptimizeReport(ctx, [...generated, ".prismo/optimize-report.md"]);
   const writtenReport = writeOptimizeReport(ctx.root, path.join(".prismo", "optimize-report.md"), report);

package/lib/prismo-dev-scan.js

@@ -53,12 +53,13 @@ const {
   fs,
   path,
   NPX_COMMAND,
+  PACKAGE_VERSION,
+  estimateTokens,
   scanRepo: (...args) => scanRepo(...args),
   safeReadJson,
   readIfText,
   formatBytes: (...args) => formatBytes(...args),
   color,
-  writeGeneratedFile: (...args) => writeGeneratedFile(...args),
 });
 
 const {
@@ -588,7 +589,6 @@ const { runCli } = require("./prismo-dev/cli")({
   buildMultiAgentView,
   buildSyncPayload,
   loadConfig,
-  runFirewall,
 });
 
 module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "getprismo",
-  "version": "0.1.59",
+  "version": "0.1.61",
   "description": "Local AI coding workflow scanner for Codex, Claude Code, Cursor, and token-waste diagnostics.",
   "license": "MIT",
   "homepage": "https://github.com/shanirsh/prismodev#readme",