harnery 0.0.1 → 0.2.1

package/dist/commands/callers.js

@@ -0,0 +1,276 @@
+import { spawn } from "node:child_process";
+const DEFAULT_EXCLUDE_DIRS = [
+    ".git",
+    ".cache",
+    "node_modules",
+    "dist",
+    "build",
+    "out",
+    ".next",
+    "vendor",
+    "__pycache__",
+    ".venv",
+    "tmp",
+    "tmp-files",
+    "coverage",
+    ".parcel-cache",
+    ".turbo",
+    ".harnery",
+];
+// (no file-name excludes by default).
+const DEFAULT_EXCLUDE_FILES = [];
+const LANG_GLOBS = {
+    ts: ["*.ts", "*.tsx"],
+    js: ["*.js", "*.jsx", "*.mjs", "*.cjs"],
+    py: ["*.py"],
+    php: ["*.php"],
+    rb: ["*.rb"],
+    go: ["*.go"],
+    rs: ["*.rs"],
+};
+export function registerCallersCommand(program, emit, context) {
+    program
+        .command("callers <symbol>")
+        .description("Find references to a symbol across the monorepo with kind classification " +
+        "(call / import / type / decl / ref). Heuristic: filters out declarations + " +
+        "single-line comments by default; opt back in with --include-decl / --include-comments.")
+        .option("--repo <name>", "Scope to one submodule (`.` = parent repo root)")
+        .option("--all-repos", "Search parent + every submodule")
+        .option("--lang <lang>", `File type preset (${Object.keys(LANG_GLOBS).join(", ")})`)
+        .option("--include-decl", "Include the declaration line(s) too")
+        .option("--include-comments", "Include matches in single-line comments")
+        .option("--limit <n>", "Truncate output to N matches total", "500")
+        .option("--json", "Structured JSON envelope")
+        .action(async (symbol, opts) => {
+        try {
+            const result = await runCallers(symbol, opts, context);
+            if (opts.json) {
+                emit.config({ format: "json" });
+                emit.data(result);
+                return;
+            }
+            emit.text(`${renderCallers(result)}\n`);
+        }
+        catch (err) {
+            emit.error({ code: "callers_failed", message: err.message });
+            process.exit(1);
+        }
+    });
+}
+async function runCallers(symbol, opts, context) {
+    if (!/^[A-Za-z_$][\w$]*$/.test(symbol)) {
+        throw new Error(`symbol must be a valid identifier (got: ${symbol})`);
+    }
+    const started = Date.now();
+    const repos = resolveRepos(opts, context);
+    const limit = opts.limit ? Number.parseInt(opts.limit, 10) : 500;
+    const allCallers = [];
+    let truncated = false;
+    for (const repo of repos) {
+        if (allCallers.length >= limit) {
+            truncated = true;
+            break;
+        }
+        const remaining = limit - allCallers.length;
+        const found = await grepInRepo(symbol, opts, repo, remaining);
+        if (found.truncated)
+            truncated = true;
+        allCallers.push(...found.callers);
+    }
+    const by_kind = {};
+    for (const c of allCallers) {
+        by_kind[c.kind] = (by_kind[c.kind] || 0) + 1;
+    }
+    return {
+        symbol,
+        repos: repos.map((r) => ({ name: r.name, cwd: r.cwd })),
+        callers: allCallers,
+        by_kind,
+        total: allCallers.length,
+        truncated,
+        elapsed_ms: Date.now() - started,
+    };
+}
+function resolveRepos(opts, context) {
+    const repoRoot = context?.repoRoot;
+    const submodules = context?.submodules;
+    if (opts.allRepos) {
+        if (!repoRoot || !submodules) {
+            throw new Error("--all-repos requires harnery to be configured with repoRoot + submodules");
+        }
+        const out = [{ name: "parent", cwd: repoRoot }];
+        for (const name of submodules)
+            out.push({ name, cwd: `${repoRoot}/${name}` });
+        return out;
+    }
+    if (opts.repo) {
+        if (opts.repo === "." || opts.repo === "parent") {
+            if (!repoRoot) {
+                throw new Error('--repo "." requires harnery to be configured with repoRoot');
+            }
+            return [{ name: "parent", cwd: repoRoot }];
+        }
+        if (!submodules || !repoRoot) {
+            throw new Error(`--repo "${opts.repo}" requires harnery to be configured with repoRoot + submodules`);
+        }
+        const found = submodules.find((n) => n === opts.repo);
+        if (!found) {
+            throw new Error(`unknown repo "${opts.repo}". Valid: parent (.), ${submodules.join(", ")}`);
+        }
+        return [{ name: found, cwd: `${repoRoot}/${found}` }];
+    }
+    return [{ name: "cwd", cwd: process.cwd() }];
+}
+function grepInRepo(symbol, opts, repo, limit) {
+    const args = ["-rnw", "--color=never", "-I", "-E"];
+    for (const d of DEFAULT_EXCLUDE_DIRS)
+        args.push(`--exclude-dir=${d}`);
+    for (const f of DEFAULT_EXCLUDE_FILES)
+        args.push(`--exclude=${f}`);
+    const langGlobs = opts.lang ? LANG_GLOBS[opts.lang] : undefined;
+    if (opts.lang && !langGlobs) {
+        throw new Error(`unknown --lang "${opts.lang}". Valid: ${Object.keys(LANG_GLOBS).join(", ")}`);
+    }
+    if (langGlobs)
+        for (const g of langGlobs)
+            args.push(`--include=${g}`);
+    args.push("--", symbol, ".");
+    return new Promise((resolveP, reject) => {
+        const proc = spawn("grep", args, { cwd: repo.cwd, stdio: ["ignore", "pipe", "pipe"] });
+        const callers = [];
+        let buffer = "";
+        let stderr = "";
+        let truncated = false;
+        proc.stdout.setEncoding("utf8");
+        proc.stdout.on("data", (chunk) => {
+            if (truncated)
+                return;
+            buffer += chunk;
+            let nl = buffer.indexOf("\n");
+            while (nl >= 0) {
+                const line = buffer.slice(0, nl);
+                buffer = buffer.slice(nl + 1);
+                if (line.length !== 0) {
+                    const parsed = parseCallerLine(line, symbol, opts, repo.name);
+                    if (parsed)
+                        callers.push(parsed);
+                    if (callers.length >= limit) {
+                        truncated = true;
+                        proc.kill("SIGTERM");
+                        return;
+                    }
+                }
+                nl = buffer.indexOf("\n");
+            }
+        });
+        proc.stderr.setEncoding("utf8");
+        proc.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        proc.on("error", reject);
+        proc.on("close", (code) => {
+            if (buffer.length > 0 && !truncated) {
+                const parsed = parseCallerLine(buffer, symbol, opts, repo.name);
+                if (parsed)
+                    callers.push(parsed);
+            }
+            if (code !== null && code !== 0 && code !== 1 && !truncated) {
+                reject(new Error(`grep exited ${code}: ${stderr.trim() || "(no stderr)"}`));
+                return;
+            }
+            resolveP({ callers, truncated });
+        });
+    });
+}
+function parseCallerLine(line, symbol, opts, repoName) {
+    const firstColon = line.indexOf(":");
+    if (firstColon < 0)
+        return null;
+    const after = line.slice(firstColon + 1);
+    const secondColon = after.indexOf(":");
+    if (secondColon < 0)
+        return null;
+    const lineNum = Number.parseInt(after.slice(0, secondColon), 10);
+    if (!Number.isFinite(lineNum))
+        return null;
+    const file = line.slice(0, firstColon).replace(/^\.\//, "");
+    const text = after.slice(secondColon + 1);
+    if (!opts.includeComments) {
+        if (/^\s*(\/\/|#|--)/.test(text))
+            return null;
+    }
+    if (/^\s*\*[\s/]/.test(text))
+        return null; // /* multi-line comment continuation
+    const kind = classifyMatch(text, symbol);
+    if (kind === "decl" && !opts.includeDecl)
+        return null;
+    return { repo: repoName, file, line: lineNum, kind, text };
+}
+function classifyMatch(text, symbol) {
+    const sym = escapeRegex(symbol);
+    if (new RegExp(`^\\s*(export\\s+)?(async\\s+)?(function|class|interface|type|enum|namespace)\\s+${sym}\\b`).test(text)) {
+        return "decl";
+    }
+    if (new RegExp(`^\\s*(export\\s+)?(const|let|var)\\s+${sym}\\b`).test(text))
+        return "decl";
+    if (new RegExp(`^\\s*(public|private|protected)\\s+(static\\s+)?function\\s+${sym}\\b`).test(text)) {
+        return "decl";
+    }
+    if (new RegExp(`^\\s*(async\\s+)?def\\s+${sym}\\b`).test(text))
+        return "decl";
+    if (new RegExp(`^\\s*class\\s+${sym}\\b`).test(text))
+        return "decl";
+    if (/^\s*(import\b|from\b|use\s+|require\s*\(|include\s|require_once\s)/.test(text)) {
+        return "import";
+    }
+    if (new RegExp(`\\b${sym}\\s*\\(`).test(text))
+        return "call";
+    if (new RegExp(`(:\\s*${sym}\\b|extends\\s+${sym}\\b|implements\\s+${sym}\\b|as\\s+${sym}\\b|<${sym}[>\\s,])`).test(text)) {
+        return "type";
+    }
+    return "ref";
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function renderCallers(r) {
+    const lines = [];
+    if (r.total === 0) {
+        lines.push(`callers · ${r.symbol}: no matches`);
+        return lines.join("\n");
+    }
+    const summary = Object.entries(r.by_kind)
+        .sort((a, b) => b[1] - a[1])
+        .map(([k, n]) => `${k}=${n}`)
+        .join(", ");
+    lines.push(`callers · ${r.symbol} (${r.total} total: ${summary}, ${r.elapsed_ms}ms)`);
+    const byRepo = new Map();
+    for (const c of r.callers) {
+        if (!byRepo.has(c.repo))
+            byRepo.set(c.repo, []);
+        byRepo.get(c.repo).push(c);
+    }
+    const showRepoHeader = byRepo.size > 1;
+    for (const [repo, callers] of byRepo) {
+        if (showRepoHeader) {
+            lines.push("");
+            lines.push(`── ${repo} (${callers.length}) ──`);
+        }
+        let lastFile = "";
+        for (const c of callers) {
+            if (c.file !== lastFile) {
+                lines.push("");
+                lines.push(`  ${c.file}`);
+                lastFile = c.file;
+            }
+            const kindLabel = `[${c.kind}]`.padEnd(8);
+            const snippet = c.text.trim().slice(0, 100);
+            lines.push(`    L${c.line.toString().padEnd(5)} ${kindLabel} ${snippet}`);
+        }
+    }
+    if (r.truncated) {
+        lines.push("");
+        lines.push("(truncated; pass --limit to widen)");
+    }
+    return lines.join("\n");
+}

package/dist/commands/completion.d.ts

@@ -0,0 +1,17 @@
+import type { Command } from "commander";
+import type { EmitContext, HarneryProgramContext } from "../commander.js";
+/**
+ * `harn completion`: emit / install shell completion scripts.
+ *
+ *   harn completion bash | zsh | fish    → write generated script to stdout
+ *   harn completion install [--shell ...] → install to the conventional location
+ *
+ * And the hidden internal entry point:
+ *
+ *   harn __complete <provider> -- <partial>
+ *     Called by the generated shell scripts at tab-time for dynamic-value
+ *     completion. Returns newline-separated candidate values. Empty exit
+ *     code 0 even on errors (don't disrupt the user's tab).
+ */
+export declare function registerCompletionCommand(program: Command, _emit: EmitContext, context?: HarneryProgramContext): void;
+//# sourceMappingURL=completion.d.ts.map

package/dist/commands/completion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion.d.ts","sourceRoot":"","sources":["../../src/commands/completion.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAY1E;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,WAAW,EAClB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,IAAI,CA8DN"}

package/dist/commands/completion.js

@@ -0,0 +1,158 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { generateBash, generateFish, generateZsh, walkProgram, } from "../lib/completion/index.js";
+const noopProviderRunner = async () => [];
+const noopLookup = () => undefined;
+/**
+ * `harn completion`: emit / install shell completion scripts.
+ *
+ *   harn completion bash | zsh | fish    → write generated script to stdout
+ *   harn completion install [--shell ...] → install to the conventional location
+ *
+ * And the hidden internal entry point:
+ *
+ *   harn __complete <provider> -- <partial>
+ *     Called by the generated shell scripts at tab-time for dynamic-value
+ *     completion. Returns newline-separated candidate values. Empty exit
+ *     code 0 even on errors (don't disrupt the user's tab).
+ */
+export function registerCompletionCommand(program, _emit, context) {
+    const lookup = context?.completionLookup ?? noopLookup;
+    const runProvider = context?.completionRunner ?? noopProviderRunner;
+    const root = program
+        .command("completion")
+        .description("Shell tab-completion. Emit a script per shell or install to the standard location.");
+    root
+        .command("bash")
+        .description("Emit bash completion script to stdout")
+        .action(() => {
+        const out = generateBash(walkProgram(program, lookup), program.name());
+        process.stdout.write(out); // raw bytes: shell completion scripts must be unframed (consumer evals stdout).
+    });
+    root
+        .command("zsh")
+        .description("Emit zsh completion script to stdout")
+        .action(() => {
+        const out = generateZsh(walkProgram(program, lookup), program.name());
+        process.stdout.write(out); // raw bytes: shell completion scripts must be unframed (consumer evals stdout).
+    });
+    root
+        .command("fish")
+        .description("Emit fish completion script to stdout")
+        .action(() => {
+        const out = generateFish(walkProgram(program, lookup), program.name());
+        process.stdout.write(out); // raw bytes: shell completion scripts must be unframed (consumer evals stdout).
+    });
+    root
+        .command("install")
+        .description("Write completion script to the conventional location for the chosen shell")
+        .option("--shell <name>", "bash | zsh | fish (default: auto-detect from $SHELL)")
+        .option("--path <file>", "Override destination path")
+        .option("--print-path", "Print the destination path and exit (no write)")
+        .action(async (opts) => {
+        await installCompletion(program, opts, lookup);
+    });
+    // Hidden internal entry: shells call this at tab-time. `hidden: true` so
+    // `harn --help` doesn't surface it.
+    const hidden = program
+        .command("__complete <provider> [partial]", { hidden: true })
+        .description("Internal: dynamic-value completion callback for the shell")
+        .allowExcessArguments(true)
+        .action(async (provider, partial) => {
+        try {
+            const values = await runProvider(provider, partial ?? "");
+            for (const v of values) {
+                process.stdout.write(`${v}\n`); // lint-ok-emission: shell callback; newline-delimited raw values is the contract with compgen/_describe/fish.
+            }
+        }
+        catch {
+            // Swallow errors silently: failure during tab completion should not
+            // break the user's shell.
+        }
+    });
+    // Keep TS happy that the variable is used.
+    void hidden;
+}
+async function installCompletion(program, opts, lookup) {
+    const shell = opts.shell ?? detectShell();
+    if (!shell) {
+        process.stderr.write("Could not auto-detect shell. Pass --shell bash|zsh|fish explicitly.\n"); // lint-ok-emission: install error; stderr keeps stdout clean for --print-path piping.
+        process.exit(1);
+    }
+    const destination = opts.path ?? defaultInstallPath(shell, program.name());
+    if (opts.printPath) {
+        process.stdout.write(`${destination}\n`); // lint-ok-emission: --print-path is meant to be piped (e.g., dest=$(harn completion install --print-path)).
+        return;
+    }
+    let content;
+    switch (shell) {
+        case "bash":
+            content = generateBash(walkProgram(program, lookup), program.name());
+            break;
+        case "zsh":
+            content = generateZsh(walkProgram(program, lookup), program.name());
+            break;
+        case "fish":
+            content = generateFish(walkProgram(program, lookup), program.name());
+            break;
+        default:
+            process.stderr.write(`Unknown shell: ${shell}\n`); // lint-ok-emission: install-time error, see above.
+            process.exit(1);
+    }
+    mkdirSync(dirname(destination), { recursive: true });
+    writeFileSync(destination, content);
+    process.stderr.write(`Installed ${shell} completion to ${destination}\n`); // lint-ok-emission: install progress; stderr keeps stdout clean.
+    // Hint how to activate.
+    printActivationHint(shell, destination);
+}
+function detectShell() {
+    const shellPath = process.env.SHELL ?? "";
+    if (shellPath.endsWith("/bash"))
+        return "bash";
+    if (shellPath.endsWith("/zsh"))
+        return "zsh";
+    if (shellPath.endsWith("/fish"))
+        return "fish";
+    return null;
+}
+function defaultInstallPath(shell, binName) {
+    const home = process.env.HOME ?? "";
+    switch (shell) {
+        case "bash": {
+            // bash-completion v2 user-level location.
+            const xdg = process.env.XDG_DATA_HOME ?? resolve(home, ".local/share");
+            return resolve(xdg, `bash-completion/completions/${binName}`);
+        }
+        case "zsh": {
+            // Common $fpath user location. zsh auto-loads from ~/.zsh/completions if
+            // it's in $fpath.
+            return resolve(home, `.zsh/completions/_${binName}`);
+        }
+        case "fish": {
+            // Fish auto-loads everything in ~/.config/fish/completions/.
+            return resolve(home, `.config/fish/completions/${binName}.fish`);
+        }
+        default:
+            return resolve(home, `.${binName}-completion.${shell}`);
+    }
+}
+function printActivationHint(shell, path) {
+    switch (shell) {
+        case "bash":
+            if (existsSync(resolve(process.env.HOME ?? "", ".bashrc"))) {
+                const bashHint = `\nTo activate now in this shell: source "${path}"\nNew shells will pick it up automatically if bash-completion is enabled.\nIf completions don't fire in new shells, add this to ~/.bashrc:\n  [ -f "${path}" ] && source "${path}"\n`;
+                process.stderr.write(bashHint); // lint-ok-emission: post-install activation hint; stderr keeps stdout clean.
+            }
+            break;
+        case "zsh": {
+            const zshHint = `\nTo activate now: autoload -U compinit && compinit\nMake sure ${resolve(path, "..")} is in your $fpath. Add to ~/.zshrc:\n  fpath=(${resolve(path, "..")} $fpath)\n  autoload -U compinit && compinit\n`;
+            process.stderr.write(zshHint); // lint-ok-emission: post-install activation hint; stderr keeps stdout clean.
+            break;
+        }
+        case "fish": {
+            const fishHint = `\nFish auto-loads completions from ${resolve(path, "..")}. New shells pick it up.\nTo activate now: source "${path}"\n`;
+            process.stderr.write(fishHint); // lint-ok-emission: post-install activation hint; stderr keeps stdout clean.
+            break;
+        }
+    }
+}

package/dist/commands/config-get.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "commander";
+import type { EmitContext } from "../commander.js";
+export declare function registerConfigGetCommand(program: Command, emit: EmitContext): void;
+//# sourceMappingURL=config-get.d.ts.map

package/dist/commands/config-get.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-get.d.ts","sourceRoot":"","sources":["../../src/commands/config-get.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAuBnD,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CA2BlF"}

package/dist/commands/config-get.js

@@ -0,0 +1,131 @@
+import { existsSync, readFileSync } from "node:fs";
+import { extname, resolve } from "node:path";
+import yaml from "js-yaml";
+export function registerConfigGetCommand(program, emit) {
+    program
+        .command("config-get <file> <key>")
+        .description("Extract a single value from a JSON/YAML config file by dotted-path. " +
+        "Bracket notation supported: `config-get tsconfig.json compilerOptions.paths`.")
+        .option("--json", "Structured JSON envelope {file, format, key, value, type, found}")
+        .option("--raw", "Print raw string value (no JSON encoding wrapper)")
+        .action(async (file, key, opts) => {
+        try {
+            const result = await runConfigGet(file, key);
+            if (opts.json) {
+                emit.config({ format: "json" });
+                emit.data(result);
+                return;
+            }
+            if (!result.found) {
+                emit.error({ code: "key_not_found", message: `key "${key}" not found in ${file}` });
+                process.exit(1);
+            }
+            emit.text(`${renderValue(result.value)}\n`);
+        }
+        catch (err) {
+            emit.error({ code: "config_get_failed", message: err.message });
+            process.exit(1);
+        }
+    });
+}
+async function runConfigGet(file, key) {
+    const absPath = resolve(file);
+    if (!existsSync(absPath))
+        throw new Error(`no such file: ${file}`);
+    const content = readFileSync(absPath, "utf8");
+    const ext = extname(absPath).toLowerCase();
+    let format;
+    let parsed;
+    if (ext === ".json") {
+        format = "json";
+        try {
+            parsed = JSON.parse(content);
+        }
+        catch (err) {
+            throw new Error(`json parse failed: ${err.message}`);
+        }
+    }
+    else if (ext === ".yaml" || ext === ".yml") {
+        format = "yaml";
+        try {
+            parsed = yaml.load(content);
+        }
+        catch (err) {
+            throw new Error(`yaml parse failed: ${err.message}`);
+        }
+    }
+    else {
+        throw new Error(`unsupported file type: ${ext || "(no extension)"} (supported: .json, .yaml, .yml)`);
+    }
+    const parts = parseDottedPath(key);
+    let cur = parsed;
+    let found = true;
+    for (const p of parts) {
+        if (cur == null || typeof cur !== "object") {
+            found = false;
+            cur = undefined;
+            break;
+        }
+        const obj = cur;
+        if (!(p in obj)) {
+            found = false;
+            cur = undefined;
+            break;
+        }
+        cur = obj[p];
+    }
+    const type = cur === null
+        ? "null"
+        : Array.isArray(cur)
+            ? "array"
+            : cur === undefined
+                ? "undefined"
+                : typeof cur;
+    return {
+        file,
+        format,
+        key,
+        value: cur,
+        type,
+        found,
+    };
+}
+function parseDottedPath(path) {
+    const parts = [];
+    let i = 0;
+    while (i < path.length) {
+        if (path[i] === ".") {
+            i++;
+            continue;
+        }
+        if (path[i] === "[") {
+            const end = path.indexOf("]", i);
+            if (end < 0)
+                throw new Error(`unmatched [ in key: ${path}`);
+            let inner = path.slice(i + 1, end);
+            if ((inner.startsWith('"') && inner.endsWith('"')) ||
+                (inner.startsWith("'") && inner.endsWith("'"))) {
+                inner = inner.slice(1, -1);
+            }
+            parts.push(inner);
+            i = end + 1;
+            continue;
+        }
+        let end = i;
+        while (end < path.length && path[end] !== "." && path[end] !== "[")
+            end++;
+        parts.push(path.slice(i, end));
+        i = end;
+    }
+    return parts;
+}
+function renderValue(value) {
+    if (value === undefined)
+        return "";
+    if (typeof value === "string")
+        return value;
+    if (value === null || typeof value === "boolean" || typeof value === "number") {
+        return String(value);
+    }
+    return JSON.stringify(value, null, 2);
+}

package/dist/commands/context.d.ts

@@ -0,0 +1,11 @@
+import type { Command } from "commander";
+import type { EmitContext, HarneryProgramContext } from "../commander.js";
+/**
+ * `harn context`: one-shot orientation snapshot.
+ *
+ * Aggregates self / time / repo / commits / submodules / peers (default) plus
+ * opt-in services. Useful at session start, post-compaction, or before
+ * dispatching subagents. Fail-open per section.
+ */
+export declare function registerContextCommand(program: Command, emit: EmitContext, context?: HarneryProgramContext): void;
+//# sourceMappingURL=context.d.ts.map

package/dist/commands/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/commands/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAS1E;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,WAAW,EACjB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,IAAI,CAiDN"}