hologit 0.47.5 → 0.48.1

package/.claude-plugin/marketplace.json

@@ -0,0 +1,18 @@
+{
+  "name": "hologit",
+  "owner": {
+    "name": "Jarvus Innovations",
+    "email": "hello@jarv.us"
+  },
+  "metadata": {
+    "description": "Skills for working with hologit"
+  },
+  "plugins": [
+    {
+      "name": "hologit",
+      "source": "./",
+      "description": "Hologit configuration and CLI assistance",
+      "skills": ["./skills/hologit"]
+    }
+  ]
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,11 @@
+{
+  "name": "hologit",
+  "description": "Skills for configuring and using hologit",
+  "version": "1.0.0",
+  "author": {
+    "name": "Jarvus Innovations",
+    "email": "hello@jarv.us"
+  },
+  "repository": "https://github.com/JarvusInnovations/hologit",
+  "license": "MIT"
+}

package/README.md

@@ -60,19 +60,19 @@ Lenses are configured in `.holo/lenses/` and can be chained together to form com
 git holo init
 ```
 
-2. Create a holobranch:
+1. Create a holobranch:
 
 ```bash
 git holo branch create my-branch
 ```
 
-3. Add a source:
+1. Add a source:
 
 ```bash
 git holo source create https://github.com/example/repo
 ```
 
-4. Project your holobranch:
+1. Project your holobranch:
 
 ```bash
 git holo project my-branch
@@ -97,6 +97,17 @@ See the [Installation Guide](docs/grand-tour/installation.md) and [Grand Tour](d
 - **Deployment**: Prepare deployment artifacts with consistent transformations
 - **Code Generation**: Automate code generation and transformation workflows
 
+## Claude Code Plugin
+
+Hologit includes a [Claude Code](https://docs.anthropic.com/en/docs/claude-code) plugin that gives Claude deep knowledge of hologit's configuration system, CLI, stock lenses, and workflows.
+
+```bash
+/plugin marketplace add JarvusInnovations/hologit
+/plugin install hologit@hologit
+```
+
+Once installed, Claude can help you configure `.holo/` files, set up sources and mappings, choose and configure stock lenses, and debug projection issues.
+
 ## Documentation
 
 - [Installation Guide](docs/grand-tour/installation.md)

package/commands/inspect.js

@@ -0,0 +1,162 @@
+exports.command = 'inspect [holobranch]';
+exports.desc = 'Display the fully resolved hologit configuration';
+
+exports.builder = {
+    'holobranch': {
+        describe: 'Name of a specific holobranch to inspect'
+    },
+    'ref': {
+        describe: 'Commit ref to read configuration from',
+        default: 'HEAD'
+    },
+    'working': {
+        describe: 'Use the (possibly uncommitted) contents of the working tree',
+        type: 'boolean',
+        default: false
+    }
+};
+
+exports.handler = async function inspect ({
+    holobranch,
+    ref = 'HEAD',
+    working = false
+}) {
+    const { Repo } = require('../lib');
+
+    const repo = await Repo.getFromEnvironment({ ref, working });
+    const workspace = await repo.getWorkspace();
+    const { name: workspaceName } = await workspace.getCachedConfig();
+
+    if (holobranch) {
+        const branch = workspace.getBranch(holobranch);
+        if (!await branch.isDefined()) {
+            throw new Error(`holobranch not defined: ${holobranch}`);
+        }
+        await printBranch(workspace, workspaceName, branch, '');
+    } else {
+        await printWorkspace(workspace, workspaceName);
+    }
+};
+
+
+async function printWorkspace (workspace, workspaceName) {
+    console.log(`Workspace: ${workspaceName}`);
+
+    // sources
+    const sources = await workspace.getSources();
+    if (sources.size) {
+        console.log('\nSources:');
+        for (const [name, source] of sources) {
+            await printSource(source, '  ');
+        }
+    }
+
+    // branches
+    const branches = await workspace.getBranches();
+    if (branches.size) {
+        console.log('\nBranches:');
+        for (const [name, branch] of branches) {
+            if (await branch.isDefined()) {
+                console.log('');
+                await printBranch(workspace, workspaceName, branch, '  ');
+            }
+        }
+    }
+}
+
+
+async function printBranch (workspace, workspaceName, branch, indent) {
+    const config = await branch.getCachedConfig();
+    const label = config.extend
+        ? `${branch.name} (extends: ${config.extend})`
+        : branch.name;
+    console.log(`${indent}${label}`);
+
+    // mappings
+    const mappings = await branch.getMappings();
+    if (mappings.size) {
+        console.log(`${indent}  Mappings (${mappings.size}):`);
+        for (const [key, mapping] of mappings) {
+            await printMapping(workspace, workspaceName, mapping, `${indent}    `);
+        }
+    }
+
+    // lenses
+    const lenses = await branch.getLenses();
+    if (lenses.size) {
+        console.log(`${indent}  Lenses (${lenses.size}):`);
+        for (const [name, lens] of lenses) {
+            await printLens(lens, `${indent}    `);
+        }
+    }
+}
+
+
+async function printMapping (workspace, workspaceName, mapping, indent) {
+    const config = await mapping.getCachedConfig();
+
+    const isWorkspace = config.holosource === workspaceName;
+    const sourceLabel = isWorkspace
+        ? `${config.holosource} (workspace)`
+        : config.holosource;
+
+    console.log(`${indent}${mapping.key}`);
+    console.log(`${indent}  source:  ${sourceLabel}`);
+    console.log(`${indent}  files:   ${config.files.join(', ')}`);
+    console.log(`${indent}  root:    ${config.root}`);
+    console.log(`${indent}  output:  ${config.output}`);
+    console.log(`${indent}  layer:   ${config.layer}`);
+
+    if (config.after) {
+        console.log(`${indent}  after:   ${config.after.join(', ')}`);
+    }
+    if (config.before) {
+        console.log(`${indent}  before:  ${config.before.join(', ')}`);
+    }
+}
+
+
+async function printLens (lens, indent) {
+    const config = await lens.getCachedConfig();
+
+    console.log(`${indent}${lens.name}`);
+
+    if (config.container) {
+        console.log(`${indent}  container: ${config.container}`);
+    } else if (config.package) {
+        console.log(`${indent}  package:   ${config.package}`);
+    }
+
+    const inputRoot = config.input.root === '.' ? '.' : config.input.root;
+    const inputFiles = config.input.files.join(', ');
+    console.log(`${indent}  input:     ${inputRoot}/{${inputFiles}}`);
+
+    const outputRoot = config.output.root === '.' ? '.' : config.output.root;
+    console.log(`${indent}  output:    ${outputRoot}/ (${config.output.merge})`);
+
+    if (config.after) {
+        console.log(`${indent}  after:     ${config.after.join(', ')}`);
+    }
+    if (config.before) {
+        console.log(`${indent}  before:    ${config.before.join(', ')}`);
+    }
+}
+
+
+async function printSource (source, indent) {
+    const config = await source.getCachedConfig();
+
+    if (config.$workspace) {
+        console.log(`${indent}${source.name} (workspace)`);
+    } else {
+        const ref = config.ref || '';
+        const url = config.url || '';
+        console.log(`${indent}${source.name}`);
+        console.log(`${indent}  url: ${url}`);
+        console.log(`${indent}  ref: ${ref}`);
+
+        if (config.project && config.project.holobranch) {
+            console.log(`${indent}  project: ${config.project.holobranch}`);
+        }
+    }
+}

package/lib/Workspace.js

@@ -107,24 +107,30 @@ class Workspace extends Configurable {
         const children = tree ? await tree.getChildren() : {};
 
 
-        // build unsorted map
+        // build unsorted map via recursive discovery
         const childNameRe = /^([^\/]+)\.toml$/;
         const map = new Map();
-        for (const childName in children) {
-            let name;
 
-            // process trees or files ending in .toml
+        for (const childName in children) {
             if (children[childName].isTree) {
-                name = childName;
+                // skip .lenses directories (e.g. "docs-site.lenses")
+                if (childName.endsWith('.lenses')) {
+                    continue;
+                }
+
+                // peek inside: if directory contains .toml files it defines
+                // a branch's mappings; otherwise it's a namespace — recurse
+                await this._discoverBranches(
+                    children[childName], childName, childNameRe, map
+                );
             } else {
                 const nameMatches = childName.match(childNameRe);
                 if (!nameMatches) {
                     continue;
                 }
-                [,name] = nameMatches;
+                const [,name] = nameMatches;
+                map.set(name, this.getBranch(name));
             }
-
-            map.set(name, this.getBranch(name));
         }
 
 
@@ -133,6 +139,35 @@ class Workspace extends Configurable {
         return map;
     }
 
+    async _discoverBranches (tree, prefix, childNameRe, map) {
+        const treeChildren = await tree.getChildren();
+
+        // check if this directory contains any .toml files directly
+        let hasTomlFiles = false;
+        for (const name in treeChildren) {
+            if (!treeChildren[name].isTree && childNameRe.test(name)) {
+                hasTomlFiles = true;
+                break;
+            }
+        }
+
+        if (hasTomlFiles) {
+            // directory contains mappings — it defines a branch
+            map.set(prefix, this.getBranch(prefix));
+        } else {
+            // no .toml files — it's a namespace, recurse into subdirectories
+            for (const name in treeChildren) {
+                if (!treeChildren[name].isTree || name.endsWith('.lenses')) {
+                    continue;
+                }
+
+                await this._discoverBranches(
+                    treeChildren[name], prefix + '/' + name, childNameRe, map
+                );
+            }
+        }
+    }
+
     getSource (name) {
         let cache = sourceCache.get(this);
         const cachedSource = cache && cache.get(name);
@@ -173,7 +208,7 @@ class Workspace extends Configurable {
 
         // read tree
         const tree = await this.root.getSubtree(`.holo/sources`);
-        const children = await tree.getChildren();
+        const children = tree ? await tree.getChildren() : {};
 
 
         // build unsorted map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hologit",
-  "version": "0.47.5",
+  "version": "0.48.1",
   "description": "Hologit automates the projection of layered composite file trees based on flat, declarative plans",
   "repository": "https://github.com/JarvusInnovations/hologit",
   "main": "lib/index.js",
@@ -11,14 +11,14 @@
   "dependencies": {
     "@iarna/toml": "^2.2.5",
     "async-exit-hook": "^2.0.1",
-    "axios": "^1.13.2",
+    "axios": "^1.13.5",
     "chokidar": "^5.0.0",
     "debounce": "^3.0.0",
     "fb-watchman": "^2.0.2",
     "git-client": "^1.9.4",
     "hab-client": "^1.1.3",
     "handlebars": "^4.7.8",
-    "minimatch": "^10.1.1",
+    "minimatch": "^10.2.2",
     "mz": "^2.7.0",
     "mz-modules": "^2.1.0",
     "object-squish": "^1.1.0",