omgbase 0.1.0

package/dist/src/shell/session.js

@@ -0,0 +1,317 @@
+import { Style } from "../style.js";
+import { makeCli } from "../context.js";
+import { CliUsageError, EXIT_OK, EXIT_ERROR, EXIT_USAGE, renderError } from "../output.js";
+import { runCommand, parseGlobals } from "../dispatch.js";
+import { tokenize, TokenizeError } from "./tokenize.js";
+import { parseRef, deriveRows, coerce, RefError, } from "./refs.js";
+export class ShellSession {
+    workspace;
+    cwd;
+    io;
+    style;
+    server;
+    headers;
+    bindings = new Map();
+    frame = null;
+    last;
+    /** Set by `exit`/`quit`; the interactive loop watches this. */
+    exited = false;
+    constructor(opts) {
+        this.workspace = opts.workspace;
+        this.cwd = opts.cwd;
+        this.io = opts.io;
+        this.server = opts.server;
+        this.headers = opts.headers;
+        const noColor = opts.noColor ?? !opts.io.stdoutTTY;
+        this.style = new Style({ noColor, isTTY: opts.io.stdoutTTY });
+    }
+    /** Execute one input line. Returns an exit code (0 ok, 1 error, 2 usage). */
+    async exec(line) {
+        const trimmed = line.trim();
+        if (trimmed === "" || trimmed.startsWith("#"))
+            return EXIT_OK; // blank / comment
+        let tokens;
+        try {
+            tokens = tokenize(line);
+        }
+        catch (err) {
+            if (err instanceof TokenizeError)
+                return this.usage(err.message);
+            throw err;
+        }
+        if (tokens.length === 0)
+            return EXIT_OK;
+        try {
+            const head = tokens[0];
+            switch (head) {
+                case "exit":
+                case "quit":
+                    this.exited = true;
+                    return EXIT_OK;
+                case "unset":
+                    return this.doUnset(tokens.slice(1));
+                case "bindings":
+                    return this.doBindings();
+                case "?":
+                    return this.doShellHelp();
+                default: {
+                    const ref = parseRef(head); // null unless `@…`; throws on a malformed `@…`
+                    // `@name = <command | @ref>` binds a snapshot (the command runs
+                    // quietly). A bare reference on its own line inspects the value (and,
+                    // if it's a collection, makes it the addressable frame). Anything else
+                    // is a normal omg command line with `@refs` substituted into its argv.
+                    if (ref && tokens[1] === "=")
+                        return await this.doAssign(ref, tokens.slice(2));
+                    if (ref && tokens.length === 1)
+                        return this.inspect(head);
+                    return await this.runLine(tokens);
+                }
+            }
+        }
+        catch (err) {
+            if (err instanceof RefError || err instanceof CliUsageError || err instanceof TokenizeError) {
+                return this.usage(err.message);
+            }
+            return renderError(err, this.io, this.style, false);
+        }
+    }
+    // ---- builtins -------------------------------------------------------------
+    /**
+     * `@name = <command | @ref>` — bind a snapshot of a result under `name`.
+     * A command runs quietly (stdout suppressed); a bare `@ref` copies its value.
+     * The target must be a plain name (no `[i]`/`.field`, not `@_`/`@N`).
+     */
+    async doAssign(target, rhs) {
+        const name = target.base;
+        if (target.index !== undefined || target.field !== undefined) {
+            return this.usage("cannot assign to @name[i] or @name.field — bind a whole result to @name");
+        }
+        if (!/^[A-Za-z][\w-]*$/.test(name) || name === "_") {
+            return this.usage(`bad binding name '@${name}' (use a letter-led identifier)`);
+        }
+        if (rhs.length === 0)
+            return this.usage("@name = <command | @ref>");
+        let captured;
+        if (rhs.length === 1 && parseRef(rhs[0])) {
+            // @x = @ref  — snapshot the referenced value.
+            const { value } = this.resolveRef(rhs[0]);
+            captured = { value, rows: deriveRows(value) };
+        }
+        else {
+            // @x = <command>  — run it quietly (stdout suppressed) and snapshot the
+            // typed result. Diagnostics/errors still reach the user via stderr.
+            const substituted = this.substitute(rhs);
+            let value;
+            const code = await this.dispatch(substituted, (v) => (value = v), true);
+            if (code !== EXIT_OK)
+                return code; // command failed → don't bind
+            captured = { value, rows: deriveRows(value) };
+        }
+        this.bindings.set(name, captured);
+        this.last = { value: captured.value };
+        this.io.err(this.style.dim(`  @${name} = ${this.summary(captured)}`));
+        return EXIT_OK;
+    }
+    doUnset(rest) {
+        const name = rest[0];
+        if (!name)
+            return this.usage("unset <name>");
+        if (this.bindings.delete(name)) {
+            this.io.err(this.style.dim(`  unset @${name}`));
+        }
+        else {
+            this.io.err(this.style.dim(`  no binding @${name}`));
+        }
+        return EXIT_OK;
+    }
+    doBindings() {
+        if (this.bindings.size === 0) {
+            this.io.err(this.style.dim("  no bindings"));
+            return EXIT_OK;
+        }
+        for (const [name, cap] of this.bindings) {
+            this.io.out(`${this.style.accent(`@${name}`)}  ${this.style.dim(this.summary(cap))}`);
+        }
+        return EXIT_OK;
+    }
+    doShellHelp() {
+        const { io, style } = this;
+        const line = (s) => io.out("  " + s);
+        io.out(style.bold("  omg shell — session bindings"));
+        line(style.dim("run any omg command; results become addressable:"));
+        line(`${style.accent("@1 @2 …")}   ${style.dim("rows of the last displayed collection")}`);
+        line(`${style.accent("@_")}         ${style.dim("the previous command's result")}`);
+        line(`${style.accent("@name")}      ${style.dim("a named binding (also @name[i], @name.field)")}`);
+        line("");
+        line(`${style.accent("@x = <cmd|@ref>")}      ${style.dim("bind a snapshot of a result")}`);
+        line(`${style.accent("unset x")}              ${style.dim("drop a binding")}`);
+        line(`${style.accent("bindings")}             ${style.dim("list bindings")}`);
+        line(`${style.accent("exit")} / ${style.accent("quit")}          ${style.dim("leave the shell")}`);
+        return EXIT_OK;
+    }
+    // ---- command lines --------------------------------------------------------
+    /** A normal omg command line: substitute refs, dispatch, record the result. */
+    async runLine(tokens) {
+        const substituted = this.substitute(tokens);
+        return this.dispatch(substituted, (v) => this.record(v), false);
+    }
+    /**
+     * Build a per-line Cli over the shared Workspace and run the command through
+     * the same path as a one-shot invocation (freshness sweep + dispatch + error
+     * mapping). `sink` receives the command's typed result; `quiet` drops stdout
+     * (used by `let`, which snapshots rather than displays).
+     */
+    async dispatch(tokens, sink, quiet) {
+        const { flags, command, rest } = parseGlobals(tokens);
+        if (!command)
+            return EXIT_OK;
+        // In a remote session, thread the server address into every line (unless the
+        // line names its own) so each command runs against the shared remote engine.
+        if (this.server !== undefined && flags.server === undefined) {
+            flags.server = this.server;
+            if (this.headers && flags.headers === undefined)
+                flags.headers = this.headers;
+        }
+        const io = quiet ? this.quietIO() : this.io;
+        const cli = makeCli(flags, io, { ...(this.workspace ? { workspace: this.workspace } : {}), cwd: this.cwd, capture: sink });
+        return runCommand(cli, command, rest);
+    }
+    /** Update @_ and, when the result is a collection, replace the numbered frame. */
+    record(value) {
+        this.last = { value };
+        const rows = deriveRows(value);
+        if (rows) {
+            this.frame = rows;
+            if (rows.length > 0) {
+                this.io.err(this.style.dim(`  ${rows.length} row${rows.length === 1 ? "" : "s"} — address with @1..@${rows.length}`));
+            }
+        }
+    }
+    /** Inspect a bare `@ref` line: print it and, if a collection, make it the frame. */
+    inspect(token) {
+        const { value, ref } = this.resolveRef(token);
+        const rows = deriveRows(value);
+        if (rows) {
+            this.frame = rows;
+            for (let i = 0; i < rows.length; i++) {
+                const r = rows[i];
+                this.io.out(`${this.style.dim(`[${i + 1}]`)} ${this.style.id(r.ref)}  ${this.style.accent(r.label)}`.trimEnd());
+            }
+            this.io.err(this.style.dim(`  ${rows.length} row${rows.length === 1 ? "" : "s"}`));
+        }
+        else if (typeof value === "string") {
+            this.io.out(value);
+        }
+        else if (ref !== undefined) {
+            this.io.out(ref);
+        }
+        else {
+            // A scalar or a record: show its id/locator if coercible, else JSON.
+            try {
+                this.io.out(coerce(value));
+            }
+            catch {
+                this.io.out(JSON.stringify(value));
+            }
+        }
+        this.last = { value };
+        return EXIT_OK;
+    }
+    // ---- reference resolution -------------------------------------------------
+    /** Replace whole-token `@refs` with their coerced argv strings. */
+    substitute(tokens) {
+        return tokens.map((t) => {
+            const parsed = parseRef(t);
+            if (!parsed)
+                return t;
+            const { value, ref } = this.resolveRef(t);
+            // A known row id is used verbatim; otherwise coerce (which refuses a bare
+            // collection, forcing the user to pick a row with [i]).
+            return ref ?? coerce(value);
+        });
+    }
+    /**
+     * Resolve a reference token to its typed value plus, when known, a direct
+     * argv-usable id/locator. Coercion is deferred to the caller (substitution)
+     * so that inspecting a bare collection reference does not error.
+     */
+    resolveRef(token) {
+        const parsed = parseRef(token);
+        if (!parsed)
+            throw new RefError(`not a reference: '${token}'`);
+        let value;
+        let ref; // a known id/locator for the current row, if any
+        if (parsed.base === "_") {
+            if (!this.last)
+                throw new RefError("no previous result (@_)");
+            value = this.last.value;
+        }
+        else if (/^\d+$/.test(parsed.base)) {
+            if (!this.frame)
+                throw new RefError("no displayed collection to index with @N");
+            const row = this.frame[Number(parsed.base) - 1];
+            if (!row)
+                throw new RefError(`@${parsed.base} out of range (${this.frame.length} row${this.frame.length === 1 ? "" : "s"})`);
+            value = row.value;
+            ref = row.ref;
+        }
+        else {
+            const binding = this.bindings.get(parsed.base);
+            if (!binding)
+                throw new RefError(`no binding @${parsed.base}`);
+            value = binding.value;
+        }
+        if (parsed.index !== undefined) {
+            const rows = deriveRows(value);
+            if (!rows)
+                throw new RefError(`@${parsed.base} is not a collection to index with [i]`);
+            const row = rows[parsed.index - 1];
+            if (!row)
+                throw new RefError(`[${parsed.index}] out of range (${rows.length} item${rows.length === 1 ? "" : "s"})`);
+            value = row.value;
+            ref = row.ref;
+        }
+        if (parsed.field !== undefined) {
+            if (!value || typeof value !== "object")
+                throw new RefError(`cannot read .${parsed.field} of a non-object`);
+            const o = value;
+            if (!(parsed.field in o))
+                throw new RefError(`no field .${parsed.field}`);
+            value = o[parsed.field];
+            ref = undefined; // no longer a row id — coerce from the field value
+        }
+        return ref !== undefined ? { value, ref } : { value };
+    }
+    // ---- helpers --------------------------------------------------------------
+    summary(cap) {
+        if (cap.rows)
+            return `${cap.rows.length} row${cap.rows.length === 1 ? "" : "s"}`;
+        const v = cap.value;
+        if (typeof v === "string")
+            return v.length > 48 ? `"${v.slice(0, 45)}…"` : `"${v}"`;
+        if (typeof v === "number" || typeof v === "boolean")
+            return String(v);
+        if (v && typeof v === "object") {
+            const o = v;
+            const id = o.id ?? o.node ?? o.path ?? o.locator;
+            return id ? String(id) : "record";
+        }
+        return "empty";
+    }
+    usage(message) {
+        this.io.err(`${this.style.err("usage")}: ${message}`);
+        return EXIT_USAGE;
+    }
+    /** An IO that drops stdout (data) but forwards stderr (diagnostics). */
+    quietIO() {
+        const base = this.io;
+        return {
+            out: () => { },
+            err: (s) => base.err(s),
+            stdoutTTY: base.stdoutTTY,
+            stderrTTY: base.stderrTTY,
+        };
+    }
+}
+export { EXIT_OK, EXIT_ERROR };
+//# sourceMappingURL=session.js.map

package/dist/src/shell/tokenize.d.ts

@@ -0,0 +1,3 @@
+export declare class TokenizeError extends Error {
+}
+export declare function tokenize(line: string): string[];

package/dist/src/shell/tokenize.js

@@ -0,0 +1,79 @@
+// Shell line tokenizer (11 shell). Splits a line into argv tokens the way a
+// POSIX-ish shell would for the pieces we care about: whitespace separates
+// tokens; single quotes are literal; double quotes group with backslash escapes;
+// a backslash escapes the next char outside quotes. This is deliberately small —
+// no globbing, no variable expansion (session `@refs` are resolved separately),
+// no pipes — the shell stores and dereferences, it is not a second language.
+export class TokenizeError extends Error {
+}
+export function tokenize(line) {
+    const tokens = [];
+    let cur = "";
+    let hasCur = false; // distinguishes an empty quoted token ("") from no token
+    let i = 0;
+    const n = line.length;
+    while (i < n) {
+        const ch = line[i];
+        if (ch === " " || ch === "\t") {
+            if (hasCur) {
+                tokens.push(cur);
+                cur = "";
+                hasCur = false;
+            }
+            i++;
+            continue;
+        }
+        if (ch === "'") {
+            hasCur = true;
+            i++;
+            const end = line.indexOf("'", i);
+            if (end === -1)
+                throw new TokenizeError("unterminated single quote");
+            cur += line.slice(i, end);
+            i = end + 1;
+            continue;
+        }
+        if (ch === '"') {
+            hasCur = true;
+            i++;
+            while (i < n && line[i] !== '"') {
+                if (line[i] === "\\" && i + 1 < n) {
+                    const next = line[i + 1];
+                    // Inside double quotes only \" \\ \$ \` are special escapes; keep the
+                    // rest verbatim (backslash included) as a real shell does.
+                    if (next === '"' || next === "\\" || next === "$" || next === "`") {
+                        cur += next;
+                        i += 2;
+                        continue;
+                    }
+                }
+                cur += line[i];
+                i++;
+            }
+            if (i >= n)
+                throw new TokenizeError("unterminated double quote");
+            i++; // closing quote
+            continue;
+        }
+        if (ch === "\\") {
+            if (i + 1 < n) {
+                cur += line[i + 1];
+                hasCur = true;
+                i += 2;
+                continue;
+            }
+            // trailing backslash: treat literally
+            cur += ch;
+            hasCur = true;
+            i++;
+            continue;
+        }
+        cur += ch;
+        hasCur = true;
+        i++;
+    }
+    if (hasCur)
+        tokens.push(cur);
+    return tokens;
+}
+//# sourceMappingURL=tokenize.js.map

package/dist/src/style.d.ts

@@ -0,0 +1,58 @@
+export type Tier = "rich" | "basic" | "plain";
+export interface StyleOptions {
+    /** Force color off (--no-color, NO_COLOR, or non-TTY stdout). */
+    noColor?: boolean;
+    /** The stream we're styling for (defaults to process.stdout). */
+    isTTY?: boolean;
+}
+export declare class Style {
+    readonly tier: Tier;
+    private readonly color;
+    constructor(opts?: StyleOptions);
+    get isRich(): boolean;
+    private sgr;
+    /** 24-bit foreground when rich; falls back to a near 256-color code otherwise. */
+    private fg;
+    bold(s: string): string;
+    dim(s: string): string;
+    italic(s: string): string;
+    ok(s: string): string;
+    warn(s: string): string;
+    err(s: string): string;
+    accent(s: string): string;
+    path(s: string): string;
+    id(s: string): string;
+    /**
+     * Horizontal gradient across a string, cyan→magenta. Rich tier only; basic
+     * falls back to a flat accent, plain to the bare text. Used for the wordmark.
+     */
+    gradient(s: string, from?: [number, number, number], to?: [number, number, number]): string;
+    /** A solid gradient bar of `width` cells (rich only; degrades to a dim rule). */
+    gradientBar(width: number): string;
+}
+export interface Glyphs {
+    live: string;
+    dead: string;
+    ok: string;
+    warn: string;
+    err: string;
+    sync: string;
+    bullet: string;
+    diamond: string;
+    arrow: string;
+    taskOpen: string;
+    taskDone: string;
+    doc: string;
+    block: string;
+    heading: string;
+    queued: string;
+    tl: string;
+    tr: string;
+    bl: string;
+    br: string;
+    h: string;
+    v: string;
+    teeL: string;
+    teeR: string;
+}
+export declare function glyphs(tier: Tier): Glyphs;

package/dist/src/style.js

@@ -0,0 +1,159 @@
+// Visual capability ladder + ANSI primitives (11 §4, §8). Hand-rolled ANSI, no
+// deps. Three tiers, detected from the environment:
+//
+//   rich  — 24-bit truecolor + Nerd Font icons (gradients, per-type glyphs)
+//   basic — 16/256-color + safe unicode (● ✓ ⟳ ◆, box drawing)
+//   plain — no color, no non-ASCII (NO_COLOR, non-TTY, --json, dumb terminals)
+//
+// stdout is data; all styling is for the human-facing (TTY) path only (§4). A
+// piped or --json invocation degrades to plain automatically.
+function detectTier(opts) {
+    if (opts.noColor)
+        return "plain";
+    const isTTY = opts.isTTY ?? Boolean(process.stdout.isTTY);
+    if (!isTTY)
+        return "plain";
+    if (process.env.NO_COLOR != null)
+        return "plain";
+    if (process.env.TERM === "dumb")
+        return "plain";
+    const truecolor = process.env.COLORTERM === "truecolor" || process.env.COLORTERM === "24bit";
+    // Nerd Font heuristic: users set this convention, or common terminal programs
+    // that ship glyph fonts. Imperfect by design (11 §glyph policy) — degrade
+    // gracefully when unsure.
+    const term = `${process.env.TERM_PROGRAM ?? ""} ${process.env.LC_TERMINAL ?? ""}`.toLowerCase();
+    const nerd = process.env.OMG_NERD_FONT === "1" ||
+        process.env.NERD_FONT === "1" ||
+        /wezterm|kitty|ghostty|iterm/.test(term);
+    return truecolor && nerd ? "rich" : "basic";
+}
+const RESET = "\x1b[0m";
+export class Style {
+    tier;
+    color;
+    constructor(opts = {}) {
+        this.tier = detectTier(opts);
+        this.color = this.tier !== "plain";
+    }
+    get isRich() {
+        return this.tier === "rich";
+    }
+    // ---- raw SGR helpers ------------------------------------------------------
+    sgr(code, s) {
+        return this.color ? `\x1b[${code}m${s}${RESET}` : s;
+    }
+    /** 24-bit foreground when rich; falls back to a near 256-color code otherwise. */
+    fg(r, g, b, s) {
+        if (!this.color)
+            return s;
+        if (this.tier === "rich")
+            return `\x1b[38;2;${r};${g};${b}m${s}${RESET}`;
+        // basic tier: map to the nearest xterm-256 cube color.
+        const idx = 16 + 36 * Math.round((r / 255) * 5) + 6 * Math.round((g / 255) * 5) + Math.round((b / 255) * 5);
+        return `\x1b[38;5;${idx}m${s}${RESET}`;
+    }
+    bold(s) {
+        return this.sgr("1", s);
+    }
+    dim(s) {
+        return this.sgr("2", s);
+    }
+    italic(s) {
+        return this.sgr("3", s);
+    }
+    // ---- semantic colors ------------------------------------------------------
+    ok(s) {
+        return this.fg(64, 200, 128, s); // green
+    }
+    warn(s) {
+        return this.fg(230, 180, 60, s); // amber
+    }
+    err(s) {
+        return this.fg(228, 90, 90, s); // red
+    }
+    accent(s) {
+        return this.fg(90, 190, 235, s); // cyan
+    }
+    path(s) {
+        return this.fg(120, 180, 245, s); // soft blue
+    }
+    id(s) {
+        return this.dim(s); // IDs recede; locators are for eyes (§4.2)
+    }
+    /**
+     * Horizontal gradient across a string, cyan→magenta. Rich tier only; basic
+     * falls back to a flat accent, plain to the bare text. Used for the wordmark.
+     */
+    gradient(s, from = [90, 190, 235], to = [200, 110, 235]) {
+        if (this.tier !== "rich")
+            return this.color ? this.accent(s) : s;
+        const chars = [...s];
+        const n = Math.max(chars.length - 1, 1);
+        return (chars
+            .map((ch, i) => {
+            const t = i / n;
+            const r = Math.round(from[0] + (to[0] - from[0]) * t);
+            const g = Math.round(from[1] + (to[1] - from[1]) * t);
+            const b = Math.round(from[2] + (to[2] - from[2]) * t);
+            return `\x1b[38;2;${r};${g};${b}m${ch}`;
+        })
+            .join("") + RESET);
+    }
+    /** A solid gradient bar of `width` cells (rich only; degrades to a dim rule). */
+    gradientBar(width) {
+        if (this.tier !== "rich")
+            return this.color ? this.dim("─".repeat(width)) : "-".repeat(width);
+        const from = [90, 190, 235];
+        const to = [200, 110, 235];
+        let out = "";
+        const n = Math.max(width - 1, 1);
+        for (let i = 0; i < width; i++) {
+            const t = i / n;
+            const r = Math.round(from[0] + (to[0] - from[0]) * t);
+            const g = Math.round(from[1] + (to[1] - from[1]) * t);
+            const b = Math.round(from[2] + (to[2] - from[2]) * t);
+            out += `\x1b[38;2;${r};${g};${b}m━`;
+        }
+        return out + RESET;
+    }
+}
+// Nerd Font glyphs by codepoint (Private Use Area). Written as \u{} escapes so
+// the source is unambiguous under any editor font; they render as icons only
+// when a Nerd Font is active (the "rich" tier gate).
+const RICH = {
+    live: "\u{f111}", // nf-fa-circle
+    dead: "\u{f10c}", // nf-fa-circle_o
+    ok: "\u{f00c}", // nf-fa-check
+    warn: "\u{f071}", // nf-fa-warning
+    err: "\u{f00d}", // nf-fa-times
+    sync: "\u{f021}", // nf-fa-refresh
+    bullet: "\u{f444}", // nf-oct-dot_fill
+    diamond: "\u{f219}", // nf-fa-diamond
+    arrow: "\u{f101}", // nf-fa-angle_double_right
+    taskOpen: "\u{f096}", // nf-fa-square_o
+    taskDone: "\u{f046}", // nf-fa-check_square_o
+    doc: "\u{f15c}", // nf-fa-file_text
+    block: "\u{f0c8}", // nf-fa-square
+    heading: "\u{f1dc}", // nf-fa-header
+    queued: "\u{f017}", // nf-fa-clock_o
+    tl: "╭", tr: "╮", bl: "╰", br: "╯",
+    h: "─", v: "│", teeL: "├", teeR: "┤",
+};
+const BASIC = {
+    live: "●", dead: "○", ok: "✓", warn: "!", err: "✗",
+    sync: "⟳", bullet: "•", diamond: "◆", arrow: "›",
+    taskOpen: "☐", taskDone: "☑", doc: "▤", block: "▪",
+    heading: "§", queued: "~",
+    tl: "╭", tr: "╮", bl: "╰", br: "╯",
+    h: "─", v: "│", teeL: "├", teeR: "┤",
+};
+const PLAIN = {
+    live: "*", dead: "o", ok: "ok", warn: "!", err: "x",
+    sync: "~", bullet: "-", diamond: "*", arrow: ">",
+    taskOpen: "[ ]", taskDone: "[x]", doc: "[D]", block: "[B]", heading: "#", queued: "~",
+    tl: "+", tr: "+", bl: "+", br: "+", h: "-", v: "|", teeL: "+", teeR: "+",
+};
+export function glyphs(tier) {
+    return tier === "rich" ? RICH : tier === "basic" ? BASIC : PLAIN;
+}
+//# sourceMappingURL=style.js.map

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "omgbase",
+  "version": "0.1.0",
+  "description": "Open Markdown Graph Base — CLI",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/omgbase/omgbase.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/omgbase/omgbase#readme",
+  "bugs": {
+    "url": "https://github.com/omgbase/omgbase/issues"
+  },
+  "keywords": [
+    "markdown",
+    "knowledge-graph",
+    "sqlite",
+    "mcp",
+    "model-context-protocol",
+    "obsidian",
+    "agents",
+    "omgbase",
+    "cli",
+    "sync",
+    "search"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/corpus/**",
+    "!dist/**/*.map",
+    "!dist/**/*.tsbuildinfo",
+    "LICENSE"
+  ],
+  "type": "module",
+  "bin": {
+    "omgbase": "./dist/src/main.js",
+    "omg": "./dist/src/main.js"
+  },
+  "dependencies": {
+    "@omgbase/core": "^0.1.0",
+    "@omgbase/fs-adapter": "^0.1.0",
+    "@omgbase/sync": "^0.1.0",
+    "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "@simplebrains/recital": "^0.8.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
+  }
+}