@actions-json/bridge 0.1.121 → 0.1.124

package/lib/storage.js

@@ -14,31 +14,31 @@ function defaultStorageRoot() {
   );
 }
 
-const SCAFFOLD_DIR = path.join(__dirname, '..', 'scaffold');
+const TEMPLATE_DIR = path.join(__dirname, '..', 'template');
 
-// Recursively copy the scaffold, skipping the .gitkeep placeholders (they only
+// Recursively copy the template, skipping the .gitkeep placeholders (they only
 // exist to ship empty dirs inside the package/repo).
-function copyScaffold(src, dst) {
+function copyTemplate(src, dst) {
   fs.mkdirSync(dst, { recursive: true });
   for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
     if (entry.name === '.gitkeep') continue;
     const s = path.join(src, entry.name);
     const d = path.join(dst, entry.name);
     if (entry.isDirectory()) {
-      copyScaffold(s, d);
+      copyTemplate(s, d);
     } else {
       fs.copyFileSync(s, d);
     }
   }
 }
 
-// Ensure the storage root exists; scaffold it from the bundled template on
+// Ensure the storage root exists; create it from the bundled template on
 // first run. Returns the absolute path. Never overwrites existing storage.
 function ensureStorageRoot(root) {
   const target = root || defaultStorageRoot();
   if (!fs.existsSync(target)) {
     fs.mkdirSync(path.dirname(target), { recursive: true });
-    copyScaffold(SCAFFOLD_DIR, target);
+    copyTemplate(TEMPLATE_DIR, target);
     // Recreate the empty scope dirs that .gitkeep stood in for.
     for (const p of [
       ['scopes', 'private', 'sites'],

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@actions-json/bridge",
-  "version": "0.1.121",
-  "bridgeBinaryVersion": "0.1.119",
-  "description": "Run the actions.json MCP bridge with npx — no Rust toolchain required. Downloads the prebuilt actions-json-mcp binary, bundles the primitive dictionary, and scaffolds a storage workspace on first run.",
+  "version": "0.1.124",
+  "bridgeBinaryVersion": "0.1.186",
+  "description": "Run the actions.json MCP bridge with npx — no Rust toolchain required. Downloads the prebuilt actions-json-mcp binary, bundles the primitive dictionary, and creates your storage workspace on first run.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -17,7 +17,7 @@
     "bin/",
     "lib/",
     "dictionary/",
-    "scaffold/",
+    "template/",
     "README.md"
   ],
   "engines": {

package/{scaffold → template}/README.md

@@ -1,39 +1,37 @@
-# actions.json storage scaffold
+# actions.json storage
 
-This is a starter `actions.json.storage` workspace. The `init` step copies it to
-`.storage/` in your `actions.json` checkout, where it lives **inside the folder
-but is not part of the code repo** (`.storage/` is gitignored).
-
-Point the bridge at it with `--storage-root .storage`.
+This **is** your `actions.json.storage` workspace — operational, not an example.
+The bridge created it on first run (default: `~/.actions-json/storage`) and reads
+and writes here as your agent browses. Your browsing memory, observations, and
+action maps live in these folders.
 
 ## Scopes
 
-Storage is organized by visibility. Each scope is just a folder under `scopes/`;
-the runtime discovers site maps under `scopes/<scope>/sites/<host>/`.
+Storage is organized by visibility. Each scope is a folder under `scopes/`; the
+runtime discovers site maps under `scopes/<scope>/sites/<host>/`.
 
 | Scope | What goes here | Git |
 |---|---|---|
-| `private/` | Your owner-only browsing memory, observations, run logs, and unreviewed maps. | Local by default. Opt in: point it at your own **private** repo to sync across your machines and agents. |
+| `private/` | Your owner-only browsing memory, observations, run logs, and unreviewed maps. | Local by default. Opt in: back it with your own **private** repo to sync across your machines and agents. |
 | `public/` | Reviewed, redacted maps **you publish** openly. | Opt in: point it at your own public repo. |
 | `shared/<name>/` | Maps shared with a specific collaborator, **and** maps you pull **from** a source. | Opt in: one git remote per source. |
 
-`private` and `public` exist in the scaffold. Add `shared/<name>/` when you need
-it.
+`private` and `public` are set up. Add `shared/<name>/` when you need it.
 
-## Opening a scope for sharing or syncing
+## Versioning a scope
 
-The scaffold is local-only until you choose to version a scope. Each scope is an
-ordinary folder, so you turn one into a git repo when you want to.
+Each scope is an ordinary folder, local until you choose to version it. Turn one
+into a git repo when you want to sync or share it.
 
 **Sync your private memory across machines** — back `scopes/private/` with your
 own **private** repo so the same browsing memory follows your agent everywhere:
 
 ```bash
-cd .storage/scopes/private
+cd ~/.actions-json/storage/scopes/private
 git init && git add . && git commit -m "my private actions.json memory"
 git remote add origin https://github.com/<you>/<your-private-storage>.git  # private!
 git push -u origin main
-# on another machine: clone it into .storage/scopes/private instead of init
+# on another machine: clone it into scopes/private instead of git init
 ```
 
 This stays private — it is your repo, set to private. It only ever leaves your
@@ -43,17 +41,17 @@ requires explicit review.
 **Publish your public maps** — make `scopes/public/` your own public repo:
 
 ```bash
-cd .storage/scopes/public
+cd ~/.actions-json/storage/scopes/public
 git init && git add . && git commit -m "my public actions.json maps"
 git remote add origin https://github.com/<you>/<your-public-storage>.git
 git push -u origin main
 ```
 
 **Pull the official map library** — vendor maps *from* a source into a shared
-scope (the runtime already discovers maps under `scopes/shared/<name>/`):
+scope (the runtime discovers maps under `scopes/shared/<name>/`):
 
 ```bash
-cd .storage/scopes/shared
+cd ~/.actions-json/storage/scopes/shared
 git clone https://github.com/yaniv256/actions.json.storage.public.git actions-json
 # maps now resolve from scopes/shared/actions-json/sites/<host>/
 ```