@promptowl/contextnest-cli 0.1.0 → 0.2.0

package/LICENSE

@@ -175,7 +175,7 @@
 
    END OF TERMS AND CONDITIONS
 
-   Copyright 2025 PromptOwl, Inc.
+   Copyright 2025 PromptOwl, LLC
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/README.md

@@ -0,0 +1,90 @@
+# @promptowl/contextnest-cli
+
+Command-line tool for [Context Nest](https://github.com/PromptOwl/context-nest) — structured, versioned context vaults for AI agents.
+
+## Install
+
+```bash
+npm install -g @promptowl/contextnest-cli
+```
+
+## Quick Start
+
+```bash
+# Initialize a vault with a starter recipe
+ctx init --starter developer
+
+# See all available starters
+ctx init --list-starters
+
+# Or initialize an empty vault and build it yourself
+ctx init --name "My Vault"
+```
+
+### Available Starters
+
+| Recipe | For | What You Get |
+|--------|-----|-------------|
+| `developer` | Engineering teams | Architecture, API reference, dev setup |
+| `executive` | Leadership | Strategic vision, market landscape, decision log |
+| `analyst` | Research / OSINT | Case files, source registry, methodology |
+| `team` | General teams | Handbook, onboarding guide, runbook |
+
+## Commands
+
+### Document Management
+- `ctx add <path>` — Create a new document
+- `ctx update <path>` — Update a document
+- `ctx delete <path>` — Delete a document
+- `ctx publish <path>` — Publish (bump version, create checkpoint)
+- `ctx validate [path]` — Validate against the spec
+- `ctx list` — List documents (filter by `--type`, `--status`, `--tag`)
+- `ctx search <query>` — Full-text search
+
+### Context Injection
+- `ctx inject <selector>` — Resolve context for AI agent consumption
+- `ctx inject @org/pack` — Inject from a cloud-hosted pack
+- `ctx resolve <selector>` — Execute a selector query
+
+### Versioning & Integrity
+- `ctx history <path>` — Show version history
+- `ctx reconstruct <path> <version>` — Reconstruct a specific version
+- `ctx verify` — Verify all hash chains
+
+### Packs & Checkpoints
+- `ctx pack list` — List context packs
+- `ctx pack show <id>` — Show pack details
+- `ctx checkpoint list` — List checkpoints
+- `ctx checkpoint rebuild` — Rebuild checkpoint history
+
+### Index
+- `ctx index` — Regenerate context.yaml and INDEX.md files
+
+## Selectors
+
+```bash
+ctx inject "tag:#engineering"              # All docs with a tag
+ctx inject "type:document"                 # All docs of a type
+ctx inject "path:nodes/api-*"             # Glob match
+ctx inject "pack:engineering-essentials"   # All docs in a pack
+ctx inject "status:published"             # By status
+ctx inject "tag:#api + tag:#v2"           # Union
+ctx inject "tag:#api & status:published"  # Intersection
+```
+
+## Cloud Packs
+
+Inject context from cloud-hosted packs without downloading source files:
+
+```bash
+ctx inject @promptowl/executive-ai-strategy
+```
+
+## Links
+
+- [Context Nest repo](https://github.com/PromptOwl/context-nest)
+- [PromptOwl](https://promptowl.com)
+
+## License
+
+Apache-2.0

package/dist/chunk-ISTWO5D6.js

@@ -0,0 +1,288 @@
+#!/usr/bin/env node
+import { createRequire as __createRequire } from "node:module";
+const require = __createRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../engine/dist/chunk-ETTJRGPY.js
+function tokenize(input) {
+  const tokens = [];
+  let pos = 0;
+  function skipWhitespace() {
+    while (pos < input.length && /\s/.test(input[pos])) pos++;
+  }
+  while (pos < input.length) {
+    skipWhitespace();
+    if (pos >= input.length) break;
+    const start = pos;
+    const ch = input[pos];
+    if (ch === "+") {
+      tokens.push({ type: "AND", value: "+", position: start });
+      pos++;
+      continue;
+    }
+    if (ch === "|") {
+      tokens.push({ type: "OR", value: "|", position: start });
+      pos++;
+      continue;
+    }
+    if (ch === "-") {
+      tokens.push({ type: "NOT", value: "-", position: start });
+      pos++;
+      continue;
+    }
+    if (ch === "(") {
+      tokens.push({ type: "LPAREN", value: "(", position: start });
+      pos++;
+      continue;
+    }
+    if (ch === ")") {
+      tokens.push({ type: "RPAREN", value: ")", position: start });
+      pos++;
+      continue;
+    }
+    if (ch === "#") {
+      pos++;
+      const tagStart = pos;
+      while (pos < input.length && /[a-zA-Z0-9_-]/.test(input[pos])) pos++;
+      const tagValue = input.slice(tagStart, pos);
+      if (!tagValue) {
+        throw new Error(`Invalid tag at position ${start}: expected tag name after #`);
+      }
+      tokens.push({ type: "TAG", value: tagValue, position: start });
+      continue;
+    }
+    if (input.slice(pos).startsWith("contextnest://")) {
+      const uriStart = pos;
+      pos += "contextnest://".length;
+      while (pos < input.length && !/[\s+|\-()]/.test(input[pos])) pos++;
+      tokens.push({ type: "URI", value: input.slice(uriStart, pos), position: uriStart });
+      continue;
+    }
+    if (ch === '"') {
+      pos++;
+      const strStart = pos;
+      while (pos < input.length && input[pos] !== '"') pos++;
+      const value = input.slice(strStart, pos);
+      pos++;
+      if (value.startsWith("contextnest://")) {
+        tokens.push({ type: "URI", value, position: start });
+      } else if (value.startsWith("#")) {
+        tokens.push({ type: "TAG", value: value.slice(1), position: start });
+      } else if (value.startsWith("pack:")) {
+        tokens.push({ type: "PACK", value: value.slice(5), position: start });
+      } else {
+        tokens.push({ type: "URI", value, position: start });
+      }
+      continue;
+    }
+    const wordMatch = input.slice(pos).match(/^([a-zA-Z_][a-zA-Z0-9_]*)/);
+    if (wordMatch) {
+      const word = wordMatch[1];
+      const afterWord = pos + word.length;
+      if (afterWord < input.length && input[afterWord] === ":") {
+        pos = afterWord + 1;
+        const valueStart = pos;
+        while (pos < input.length && /[a-zA-Z0-9_-]/.test(input[pos])) pos++;
+        const filterValue = input.slice(valueStart, pos);
+        switch (word) {
+          case "type":
+            tokens.push({ type: "TYPE_FILTER", value: filterValue, position: start });
+            break;
+          case "status":
+            tokens.push({ type: "STATUS_FILTER", value: filterValue, position: start });
+            break;
+          case "transport":
+            tokens.push({ type: "TRANSPORT_FILTER", value: filterValue, position: start });
+            break;
+          case "server":
+            tokens.push({ type: "SERVER_FILTER", value: filterValue, position: start });
+            break;
+          case "pack":
+            const packStart = pos - filterValue.length;
+            pos = packStart;
+            while (pos < input.length && /[a-zA-Z0-9_.-]/.test(input[pos])) pos++;
+            tokens.push({
+              type: "PACK",
+              value: input.slice(packStart, pos),
+              position: start
+            });
+            break;
+          default:
+            throw new Error(`Unknown filter type "${word}" at position ${start}`);
+        }
+        continue;
+      }
+      throw new Error(`Unexpected token "${word}" at position ${start}`);
+    }
+    throw new Error(`Unexpected character "${ch}" at position ${pos}`);
+  }
+  tokens.push({ type: "EOF", value: "", position: pos });
+  return tokens;
+}
+var ATOM_TYPES = [
+  "TAG",
+  "URI",
+  "PACK",
+  "TYPE_FILTER",
+  "STATUS_FILTER",
+  "TRANSPORT_FILTER",
+  "SERVER_FILTER"
+];
+var SelectorParser = class {
+  tokens;
+  pos = 0;
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  peek() {
+    return this.tokens[this.pos];
+  }
+  advance() {
+    const token = this.tokens[this.pos];
+    this.pos++;
+    return token;
+  }
+  expect(type) {
+    const token = this.peek();
+    if (token.type !== type) {
+      throw new Error(
+        `Expected ${type} but got ${token.type} ("${token.value}") at position ${token.position}`
+      );
+    }
+    return this.advance();
+  }
+  isAtom() {
+    return ATOM_TYPES.includes(this.peek().type) || this.peek().type === "LPAREN";
+  }
+  parse() {
+    const result = this.parseOrExpr();
+    if (this.peek().type !== "EOF") {
+      throw new Error(
+        `Unexpected token "${this.peek().value}" at position ${this.peek().position}`
+      );
+    }
+    return result;
+  }
+  // or_expr → not_expr ("|" not_expr)*
+  parseOrExpr() {
+    let left = this.parseNotExpr();
+    while (this.peek().type === "OR") {
+      this.advance();
+      const right = this.parseNotExpr();
+      left = { type: "or", left, right };
+    }
+    return left;
+  }
+  // not_expr → and_expr ("-" and_expr)*
+  parseNotExpr() {
+    let left = this.parseAndExpr();
+    while (this.peek().type === "NOT") {
+      this.advance();
+      const right = this.parseAndExpr();
+      left = { type: "not", left, right };
+    }
+    return left;
+  }
+  // and_expr → atom (("+" | implicit) atom)*
+  parseAndExpr() {
+    let left = this.parseAtom();
+    while (true) {
+      if (this.peek().type === "AND") {
+        this.advance();
+        const right = this.parseAtom();
+        left = { type: "and", left, right };
+      } else if (this.isAtom()) {
+        const right = this.parseAtom();
+        left = { type: "and", left, right };
+      } else {
+        break;
+      }
+    }
+    return left;
+  }
+  // atom → TAG | URI | PACK | TYPE_FILTER | STATUS_FILTER |
+  //        TRANSPORT_FILTER | SERVER_FILTER | "(" expr ")"
+  parseAtom() {
+    const token = this.peek();
+    switch (token.type) {
+      case "TAG":
+        this.advance();
+        return { type: "tag", value: token.value };
+      case "URI":
+        this.advance();
+        return { type: "uri", value: token.value };
+      case "PACK":
+        this.advance();
+        return { type: "pack", value: token.value };
+      case "TYPE_FILTER":
+        this.advance();
+        return { type: "typeFilter", value: token.value };
+      case "STATUS_FILTER":
+        this.advance();
+        return { type: "statusFilter", value: token.value };
+      case "TRANSPORT_FILTER":
+        this.advance();
+        return { type: "transportFilter", value: token.value };
+      case "SERVER_FILTER":
+        this.advance();
+        return { type: "serverFilter", value: token.value };
+      case "LPAREN": {
+        this.advance();
+        const expr = this.parseOrExpr();
+        this.expect("RPAREN");
+        return expr;
+      }
+      default:
+        throw new Error(
+          `Unexpected token "${token.value}" at position ${token.position}`
+        );
+    }
+  }
+};
+function parseSelector(input) {
+  const tokens = tokenize(input);
+  const parser = new SelectorParser(tokens);
+  return parser.parse();
+}
+
+export {
+  __require,
+  __commonJS,
+  __export,
+  __toESM,
+  parseSelector
+};