@vectorize-io/hindsight-nemoclaw 0.1.1

package/README.md

@@ -0,0 +1,60 @@
+# hindsight-nemoclaw
+
+One-command setup for [Hindsight](https://hindsight.vectorize.io) persistent memory on [NemoClaw](https://nemoclaw.ai) sandboxes.
+
+NemoClaw runs [OpenClaw](https://openclaw.ai) inside an OpenShell sandbox with strict network egress policies. This package automates the full setup: installing the `hindsight-openclaw` plugin, configuring external API mode, merging the Hindsight egress rule into your sandbox policy, and restarting the gateway.
+
+## Quick Start
+
+```bash
+npx @vectorize-io/hindsight-nemoclaw setup \
+  --sandbox my-assistant \
+  --api-url https://api.hindsight.vectorize.io \
+  --api-token <your-api-key> \
+  --bank-prefix my-sandbox
+```
+
+Get an API key at [Hindsight Cloud](https://ui.hindsight.vectorize.io/signup).
+
+## Documentation
+
+Full setup guide, pitfalls, and troubleshooting:
+
+**[NemoClaw Integration Documentation](https://vectorize.io/hindsight/sdks/integrations/nemoclaw)**
+
+Or see [NEMOCLAW.md](./NEMOCLAW.md) in this directory for a step-by-step walkthrough.
+
+## CLI Reference
+
+```
+hindsight-nemoclaw setup [options]
+
+Options:
+  --sandbox <name>       NemoClaw sandbox name (required)
+  --api-url <url>        Hindsight API URL (required)
+  --api-token <token>    Hindsight API token (required)
+  --bank-prefix <prefix> Memory bank prefix (default: "nemoclaw")
+  --skip-policy          Skip sandbox network policy update
+  --skip-plugin-install  Skip openclaw plugin installation
+  --dry-run              Preview changes without applying
+  --help                 Show help
+```
+
+## What It Does
+
+1. **Preflight** — verifies `openshell` and `openclaw` are installed
+2. **Install plugin** — runs `openclaw plugins install @vectorize-io/hindsight-openclaw`
+3. **Configure plugin** — writes external API mode config to `~/.openclaw/openclaw.json`
+4. **Apply policy** — reads current sandbox policy, merges Hindsight egress rule, re-applies via `openshell policy set`
+5. **Restart gateway** — runs `openclaw gateway restart`
+
+## Links
+
+- [Hindsight Documentation](https://vectorize.io/hindsight)
+- [NemoClaw](https://nemoclaw.ai)
+- [OpenClaw](https://openclaw.ai)
+- [GitHub Repository](https://github.com/vectorize-io/hindsight)
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+import { runSetup } from './setup.js';
+function usage() {
+    process.stdout.write(`
+hindsight-nemoclaw — Setup CLI for Hindsight memory on NemoClaw sandboxes
+
+Usage:
+  hindsight-nemoclaw setup [options]
+
+Required options:
+  --sandbox <name>       NemoClaw sandbox name (e.g. my-assistant)
+  --api-url <url>        Hindsight Cloud API URL (https://api.hindsight.vectorize.io)
+  --api-token <token>    Hindsight API key from https://ui.hindsight.vectorize.io
+  --bank-prefix <prefix> Bank ID prefix (memories go to <prefix>-openclaw)
+
+Optional options:
+  --skip-policy          Skip the openshell policy update
+  --skip-plugin-install  Skip openclaw plugins install
+  --dry-run              Print what would be changed without executing
+  --help                 Show this help
+
+Example:
+  hindsight-nemoclaw setup \\
+    --sandbox my-assistant \\
+    --api-url https://api.hindsight.vectorize.io \\
+    --api-token hsk_abc123 \\
+    --bank-prefix my-sandbox
+`);
+}
+function parseArgs(argv) {
+    const args = argv.slice(2);
+    if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+        usage();
+        return null;
+    }
+    if (args[0] !== 'setup') {
+        process.stderr.write(`Unknown command: ${args[0]}\nRun with --help for usage.\n`);
+        process.exit(1);
+    }
+    const get = (flag) => {
+        const idx = args.indexOf(flag);
+        if (idx === -1 || idx + 1 >= args.length)
+            return undefined;
+        return args[idx + 1];
+    };
+    const sandbox = get('--sandbox');
+    const apiUrl = get('--api-url');
+    const apiToken = get('--api-token');
+    const bankPrefix = get('--bank-prefix');
+    const missing = [];
+    if (!sandbox)
+        missing.push('--sandbox');
+    if (!apiUrl)
+        missing.push('--api-url');
+    if (!apiToken)
+        missing.push('--api-token');
+    if (!bankPrefix)
+        missing.push('--bank-prefix');
+    if (missing.length > 0) {
+        process.stderr.write(`Missing required options: ${missing.join(', ')}\nRun with --help for usage.\n`);
+        process.exit(1);
+    }
+    return {
+        sandbox: sandbox,
+        apiUrl: apiUrl,
+        apiToken: apiToken,
+        bankPrefix: bankPrefix,
+        skipPolicy: args.includes('--skip-policy'),
+        skipPluginInstall: args.includes('--skip-plugin-install'),
+        dryRun: args.includes('--dry-run'),
+    };
+}
+const args = parseArgs(process.argv);
+if (args) {
+    runSetup(args).catch(err => {
+        process.stderr.write(`\nError: ${err instanceof Error ? err.message : String(err)}\n`);
+        process.exit(1);
+    });
+}

package/dist/openclaw-config.d.ts

@@ -0,0 +1,27 @@
+import { dirname } from 'path';
+declare const CONFIG_PATH: string;
+export interface HindsightPluginConfig {
+    hindsightApiUrl: string;
+    hindsightApiToken: string;
+    llmProvider: string;
+    dynamicBankId: boolean;
+    bankIdPrefix: string;
+}
+export interface OpenClawConfig {
+    plugins?: {
+        slots?: Record<string, string>;
+        entries?: Record<string, {
+            enabled: boolean;
+            config?: Record<string, unknown>;
+        }>;
+        installs?: Record<string, unknown>;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+export declare function readOpenClawConfig(configPath?: string): Promise<OpenClawConfig>;
+export declare function mergePluginConfig(config: OpenClawConfig, pluginConfig: HindsightPluginConfig): OpenClawConfig;
+export declare function writeOpenClawConfig(config: OpenClawConfig, configPath?: string): Promise<void>;
+export declare function applyPluginConfig(pluginConfig: HindsightPluginConfig, configPath?: string): Promise<void>;
+export { CONFIG_PATH };
+export { dirname };

package/dist/openclaw-config.js

@@ -0,0 +1,71 @@
+import { readFile, writeFile, rename } from 'fs/promises';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import { randomBytes } from 'crypto';
+const CONFIG_PATH = join(homedir(), '.openclaw', 'openclaw.json');
+export async function readOpenClawConfig(configPath = CONFIG_PATH) {
+    let raw;
+    try {
+        raw = await readFile(configPath, 'utf8');
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === 'ENOENT') {
+            throw new Error(`OpenClaw config not found at ${configPath}.\n` +
+                `Run \`openclaw\` once to initialize it, then re-run setup.`);
+        }
+        throw err;
+    }
+    return JSON.parse(raw);
+}
+export function mergePluginConfig(config, pluginConfig) {
+    const plugins = config.plugins ?? {};
+    const entries = plugins.entries ?? {};
+    const existing = entries['hindsight-openclaw'] ?? { enabled: true };
+    return {
+        ...config,
+        plugins: {
+            ...plugins,
+            slots: {
+                ...(plugins.slots ?? {}),
+                memory: 'hindsight-openclaw',
+            },
+            entries: {
+                ...entries,
+                'hindsight-openclaw': {
+                    ...existing,
+                    enabled: true,
+                    config: {
+                        ...(existing.config ?? {}),
+                        hindsightApiUrl: pluginConfig.hindsightApiUrl,
+                        hindsightApiToken: pluginConfig.hindsightApiToken,
+                        llmProvider: pluginConfig.llmProvider,
+                        dynamicBankId: pluginConfig.dynamicBankId,
+                        bankIdPrefix: pluginConfig.bankIdPrefix,
+                    },
+                },
+            },
+            installs: {
+                ...(plugins.installs ?? {}),
+                'hindsight-openclaw': {
+                    source: 'npm',
+                    version: 'latest',
+                    installedAt: new Date().toISOString(),
+                },
+            },
+        },
+    };
+}
+export async function writeOpenClawConfig(config, configPath = CONFIG_PATH) {
+    const contents = JSON.stringify(config, null, 2) + '\n';
+    const tmp = `${configPath}.${randomBytes(6).toString('hex')}.tmp`;
+    await writeFile(tmp, contents, 'utf8');
+    await rename(tmp, configPath);
+}
+export async function applyPluginConfig(pluginConfig, configPath = CONFIG_PATH) {
+    const current = await readOpenClawConfig(configPath);
+    const updated = mergePluginConfig(current, pluginConfig);
+    await writeOpenClawConfig(updated, configPath);
+}
+export { CONFIG_PATH };
+export { dirname };

package/dist/policy-reader.d.ts

@@ -0,0 +1,26 @@
+import type { SandboxPolicy } from './types.js';
+/** Strip ANSI escape codes from a string */
+export declare function stripAnsi(str: string): string;
+/**
+ * Extract and dedent the policy section from `openshell sandbox get` output.
+ * The output looks like:
+ *
+ *   Sandbox:
+ *     Id: ...
+ *     Name: ...
+ *
+ *   Policy:
+ *     version: 1
+ *     filesystem_policy:
+ *       ...
+ *
+ * We need to extract everything after `Policy:` and dedent by 2 spaces.
+ */
+export declare function extractPolicyYaml(raw: string): string;
+/**
+ * Parse `openshell sandbox get <name>` output into a SandboxPolicy object.
+ * Throws a descriptive error if parsing fails.
+ */
+export declare function parseSandboxPolicy(rawOutput: string): SandboxPolicy;
+/** Run `openshell sandbox get <sandbox>` and return parsed policy */
+export declare function readSandboxPolicy(sandboxName: string): Promise<SandboxPolicy>;

package/dist/policy-reader.js

@@ -0,0 +1,76 @@
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import yaml from 'js-yaml';
+const execFileAsync = promisify(execFile);
+/** Strip ANSI escape codes from a string */
+export function stripAnsi(str) {
+    return str.replace(/\x1B\[[0-9;]*m/g, '');
+}
+/**
+ * Extract and dedent the policy section from `openshell sandbox get` output.
+ * The output looks like:
+ *
+ *   Sandbox:
+ *     Id: ...
+ *     Name: ...
+ *
+ *   Policy:
+ *     version: 1
+ *     filesystem_policy:
+ *       ...
+ *
+ * We need to extract everything after `Policy:` and dedent by 2 spaces.
+ */
+export function extractPolicyYaml(raw) {
+    const stripped = stripAnsi(raw);
+    const lines = stripped.split('\n');
+    const policyHeaderIdx = lines.findIndex(l => l.trimEnd() === 'Policy:');
+    if (policyHeaderIdx === -1) {
+        throw new Error('Could not find "Policy:" section in `openshell sandbox get` output');
+    }
+    const policyLines = lines.slice(policyHeaderIdx + 1);
+    // Dedent by 2 spaces (the policy block is indented under `Policy:`)
+    const dedented = policyLines.map(l => {
+        if (l.startsWith('  '))
+            return l.slice(2);
+        return l;
+    });
+    // Drop trailing empty lines
+    while (dedented.length > 0 && dedented[dedented.length - 1].trim() === '') {
+        dedented.pop();
+    }
+    return dedented.join('\n');
+}
+/**
+ * Parse `openshell sandbox get <name>` output into a SandboxPolicy object.
+ * Throws a descriptive error if parsing fails.
+ */
+export function parseSandboxPolicy(rawOutput) {
+    const policyYaml = extractPolicyYaml(rawOutput);
+    try {
+        const parsed = yaml.load(policyYaml);
+        if (typeof parsed !== 'object' || parsed === null) {
+            throw new Error('Parsed policy is not an object');
+        }
+        return parsed;
+    }
+    catch (err) {
+        throw new Error(`Failed to parse sandbox policy YAML.\n` +
+            `This may mean the openshell output format has changed.\n` +
+            `Apply the Hindsight policy manually using the instructions in NEMOCLAW.md.\n` +
+            `Parse error: ${err}`);
+    }
+}
+/** Run `openshell sandbox get <sandbox>` and return parsed policy */
+export async function readSandboxPolicy(sandboxName) {
+    let stdout;
+    try {
+        const result = await execFileAsync('openshell', ['sandbox', 'get', sandboxName]);
+        stdout = result.stdout;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`Failed to run \`openshell sandbox get ${sandboxName}\`: ${msg}`);
+    }
+    return parseSandboxPolicy(stdout);
+}

package/dist/policy-writer.d.ts

@@ -0,0 +1,14 @@
+import type { SandboxPolicy } from './types.js';
+/**
+ * Returns true if the policy already has a correct Hindsight network policy entry.
+ */
+export declare function hasHindsightPolicy(policy: SandboxPolicy): boolean;
+/**
+ * Merge the Hindsight network policy block into a SandboxPolicy.
+ * Idempotent — if the block already exists and is correct, returns policy unchanged.
+ */
+export declare function mergeHindsightPolicy(policy: SandboxPolicy): SandboxPolicy;
+/**
+ * Serialize a SandboxPolicy to a YAML string suitable for `openshell policy set`.
+ */
+export declare function serializePolicy(policy: SandboxPolicy): string;

package/dist/policy-writer.js

@@ -0,0 +1,55 @@
+import yaml from 'js-yaml';
+import { HINDSIGHT_POLICY_NAME, HINDSIGHT_HOST, OPENCLAW_BINARY } from './types.js';
+const HINDSIGHT_NETWORK_POLICY = {
+    name: HINDSIGHT_POLICY_NAME,
+    endpoints: [
+        {
+            host: HINDSIGHT_HOST,
+            port: 443,
+            protocol: 'rest',
+            tls: 'terminate',
+            enforcement: 'enforce',
+            rules: [
+                { allow: { method: 'GET', path: '/**' } },
+                { allow: { method: 'POST', path: '/**' } },
+                { allow: { method: 'PUT', path: '/**' } },
+            ],
+        },
+    ],
+    binaries: [{ path: OPENCLAW_BINARY }],
+};
+/**
+ * Returns true if the policy already has a correct Hindsight network policy entry.
+ */
+export function hasHindsightPolicy(policy) {
+    const np = policy.network_policies?.[HINDSIGHT_POLICY_NAME];
+    if (!np)
+        return false;
+    return np.endpoints?.some(e => e.host === HINDSIGHT_HOST) ?? false;
+}
+/**
+ * Merge the Hindsight network policy block into a SandboxPolicy.
+ * Idempotent — if the block already exists and is correct, returns policy unchanged.
+ */
+export function mergeHindsightPolicy(policy) {
+    const updated = {
+        ...policy,
+        network_policies: {
+            ...(policy.network_policies ?? {}),
+            [HINDSIGHT_POLICY_NAME]: HINDSIGHT_NETWORK_POLICY,
+        },
+    };
+    return updated;
+}
+/**
+ * Serialize a SandboxPolicy to a YAML string suitable for `openshell policy set`.
+ */
+export function serializePolicy(policy) {
+    return yaml.dump(policy, {
+        indent: 2,
+        lineWidth: -1,
+        noRefs: true,
+        quotingType: '"',
+        forceQuotes: false,
+    });
+}

package/dist/setup.d.ts

@@ -0,0 +1,2 @@
+import type { CliArgs } from './types.js';
+export declare function runSetup(args: CliArgs): Promise<void>;

package/dist/setup.js

@@ -0,0 +1,142 @@
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { writeFile, rm } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { randomBytes } from 'crypto';
+import { readSandboxPolicy } from './policy-reader.js';
+import { hasHindsightPolicy, mergeHindsightPolicy, serializePolicy } from './policy-writer.js';
+import { applyPluginConfig } from './openclaw-config.js';
+const execFileAsync = promisify(execFile);
+function log(msg) {
+    process.stdout.write(`${msg}\n`);
+}
+function step(n, msg) {
+    log(`\n[${n}] ${msg}`);
+}
+async function which(bin) {
+    try {
+        await execFileAsync('which', [bin]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function runSetup(args) {
+    log('\nhindsight-nemoclaw setup');
+    log('─'.repeat(40));
+    // Step 0 — Preflight
+    step(0, 'Preflight checks...');
+    const [hasOpenshell, hasOpenclaw] = await Promise.all([which('openshell'), which('openclaw')]);
+    if (!hasOpenshell) {
+        throw new Error('`openshell` not found on PATH. Install it from https://openshell.ai');
+    }
+    if (!hasOpenclaw) {
+        throw new Error('`openclaw` not found on PATH. Install it from https://openclaw.ai');
+    }
+    log('  ✓ openshell found');
+    log('  ✓ openclaw found');
+    // Step 1 — Install hindsight-openclaw plugin
+    if (!args.skipPluginInstall) {
+        step(1, 'Installing @vectorize-io/hindsight-openclaw plugin...');
+        if (args.dryRun) {
+            log('  [dry-run] would run: openclaw plugins install @vectorize-io/hindsight-openclaw');
+        }
+        else {
+            const { stdout } = await execFileAsync('openclaw', [
+                'plugins', 'install', '@vectorize-io/hindsight-openclaw',
+            ]);
+            log(stdout.trim() || '  ✓ Plugin installed');
+        }
+    }
+    else {
+        step(1, 'Skipping plugin install (--skip-plugin-install)');
+    }
+    // Step 2 — Configure ~/.openclaw/openclaw.json
+    step(2, 'Configuring plugin in ~/.openclaw/openclaw.json...');
+    const pluginConfig = {
+        hindsightApiUrl: args.apiUrl,
+        hindsightApiToken: args.apiToken,
+        llmProvider: 'claude-code',
+        dynamicBankId: false,
+        bankIdPrefix: args.bankPrefix,
+    };
+    if (args.dryRun) {
+        log(`  [dry-run] would write plugin config to ~/.openclaw/openclaw.json`);
+        log(`  config: ${JSON.stringify(pluginConfig, null, 4).split('\n').join('\n  ')}`);
+    }
+    else {
+        await applyPluginConfig(pluginConfig);
+        log(`  ✓ Plugin config written (bank: ${args.bankPrefix}-openclaw)`);
+    }
+    // Step 3 — Apply OpenShell network policy
+    if (!args.skipPolicy) {
+        step(3, `Applying Hindsight network policy to sandbox "${args.sandbox}"...`);
+        const currentPolicy = await readSandboxPolicy(args.sandbox);
+        if (hasHindsightPolicy(currentPolicy)) {
+            log('  ✓ Hindsight policy already present — skipping');
+        }
+        else {
+            const updatedPolicy = mergeHindsightPolicy(currentPolicy);
+            const policyYaml = serializePolicy(updatedPolicy);
+            if (args.dryRun) {
+                log('  [dry-run] would apply policy:');
+                log(policyYaml.split('\n').map(l => `    ${l}`).join('\n'));
+            }
+            else {
+                const tmpFile = join(tmpdir(), `hindsight-policy-${randomBytes(6).toString('hex')}.yaml`);
+                try {
+                    await writeFile(tmpFile, policyYaml, 'utf8');
+                    const { stdout } = await execFileAsync('openshell', [
+                        'policy', 'set', args.sandbox, '--policy', tmpFile, '--wait',
+                    ]);
+                    log(stdout.trim() || `  ✓ Policy applied to sandbox "${args.sandbox}"`);
+                }
+                finally {
+                    await rm(tmpFile, { force: true });
+                }
+            }
+        }
+    }
+    else {
+        step(3, 'Skipping policy update (--skip-policy)');
+        log('  Add the following block to your sandbox network_policies manually:');
+        log('');
+        log('    hindsight:');
+        log('      name: hindsight');
+        log('      endpoints:');
+        log('        - host: api.hindsight.vectorize.io');
+        log('          port: 443');
+        log('          protocol: rest');
+        log('          tls: terminate');
+        log('          enforcement: enforce');
+        log('          rules:');
+        log('            - allow: { method: GET, path: /** }');
+        log('            - allow: { method: POST, path: /** }');
+        log('            - allow: { method: PUT, path: /** }');
+        log('      binaries:');
+        log('        - path: /usr/local/bin/openclaw');
+    }
+    // Step 4 — Restart gateway
+    step(4, 'Restarting OpenClaw gateway...');
+    if (args.dryRun) {
+        log('  [dry-run] would run: openclaw gateway restart');
+    }
+    else {
+        await execFileAsync('openclaw', ['gateway', 'restart']);
+        log('  ✓ Gateway restarted');
+    }
+    log('\n' + '─'.repeat(40));
+    log('✓ Setup complete!\n');
+    log(`  Bank ID: ${args.bankPrefix}-openclaw`);
+    log(`  API URL: ${args.apiUrl}`);
+    log('');
+    log('  Watch gateway logs to confirm:');
+    log('    grep Hindsight ~/.openclaw/logs/gateway.log | tail -5');
+    log('  Expected: [Hindsight] ✓ Ready (external API mode)');
+    log('');
+    log('  Test memory retention:');
+    log(`    openclaw agent --agent main --session-id test-1 -m "My name is Ben."`);
+    log(`    openclaw agent --agent main --session-id test-2 -m "What do you remember about me?"`);
+}

package/dist/types.d.ts

@@ -0,0 +1,54 @@
+export interface CliArgs {
+    sandbox: string;
+    apiUrl: string;
+    apiToken: string;
+    bankPrefix: string;
+    skipPolicy: boolean;
+    skipPluginInstall: boolean;
+    dryRun: boolean;
+}
+export interface PolicyEndpointRule {
+    allow: {
+        method: string;
+        path: string;
+    };
+}
+export interface PolicyEndpoint {
+    host: string;
+    port: number;
+    protocol?: string;
+    tls?: string;
+    enforcement?: string;
+    access?: string;
+    rules?: PolicyEndpointRule[];
+}
+export interface PolicyBinary {
+    path: string;
+}
+export interface NetworkPolicy {
+    name: string;
+    endpoints: PolicyEndpoint[];
+    binaries?: PolicyBinary[];
+}
+export interface FilesystemPolicy {
+    include_workdir?: boolean;
+    read_only?: string[];
+    read_write?: string[];
+}
+export interface Landlock {
+    compatibility?: string;
+}
+export interface ProcessPolicy {
+    run_as_user?: string;
+    run_as_group?: string;
+}
+export interface SandboxPolicy {
+    version?: number;
+    filesystem_policy?: FilesystemPolicy;
+    landlock?: Landlock;
+    process?: ProcessPolicy;
+    network_policies?: Record<string, NetworkPolicy>;
+}
+export declare const HINDSIGHT_POLICY_NAME = "hindsight";
+export declare const HINDSIGHT_HOST = "api.hindsight.vectorize.io";
+export declare const OPENCLAW_BINARY = "/usr/local/bin/openclaw";

package/dist/types.js

@@ -0,0 +1,3 @@
+export const HINDSIGHT_POLICY_NAME = 'hindsight';
+export const HINDSIGHT_HOST = 'api.hindsight.vectorize.io';
+export const OPENCLAW_BINARY = '/usr/local/bin/openclaw';

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@vectorize-io/hindsight-nemoclaw",
+  "version": "0.1.1",
+  "description": "Setup CLI for hindsight-openclaw on NemoClaw sandboxes — installs the plugin, configures external API mode, and applies the OpenShell network policy",
+  "type": "module",
+  "main": "dist/cli.js",
+  "bin": {
+    "hindsight-nemoclaw": "dist/cli.js"
+  },
+  "keywords": [
+    "nemoclaw",
+    "openclaw",
+    "memory",
+    "ai",
+    "agent",
+    "hindsight",
+    "openshell",
+    "nvidia"
+  ],
+  "author": "Vectorize <support@vectorize.io>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vectorize-io/hindsight.git",
+    "directory": "hindsight-integrations/nemoclaw"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc && node -e \"const f='dist/cli.js',s=require('fs');s.writeFileSync(f,'#!/usr/bin/env node\\n'+s.readFileSync(f,'utf8'));s.chmodSync(f,0o755)\"",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "test": "vitest run src",
+    "test:watch": "vitest src",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "dependencies": {
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^4.0.18"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}