renor-engine 0.0.0-stage → 1.0.0

package/dist/toolRefusal.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * Why an MCP tool refused a call: a CLOSED set of short, stable snake_case codes, one per refusal a caller
+ * can act on.
+ *
+ * Every failed tool call used to reach telemetry as `error_kind: "other"`, so one user's day read as "13 of
+ * 152 calls failed" with nothing to act on: no way to tell an over-long statement from an unknown memory id
+ * from a path that escapes the vault. `error_kind` says how the call ended (it is a dashboard field and its
+ * values never change); this says why it was refused, next to it, as `error_reason`.
+ *
+ * The rules this file exists to keep:
+ *
+ * - A code is a FIXED LITERAL from the list below. Nothing here is ever built from an argument, a statement,
+ *   a file, an exception message or a path, so no code can carry what the user said or wrote.
+ * - The list is closed: `isToolErrorReason` is the only way a code reaches telemetry, so a free-form string
+ *   (an exception message, say) is dropped rather than logged.
+ * - Refusal sites name their code where the refusal is decided, and the code travels out of band — in a
+ *   WeakMap beside the thrown error, or beside a refusal result the tool builds itself — instead of being
+ *   parsed back out of a message or added as a property. The error keeps the class, `name` and keys it had
+ *   before; the message still goes to the agent; the code never leaves this vocabulary.
+ * - Anything with no better code gets `refused`; an unexpected throw gets `internal`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_ERROR_REASONS = void 0;
+exports.isToolErrorReason = isToolErrorReason;
+exports.refusal = refusal;
+exports.markErrorReason = markErrorReason;
+exports.refusalReason = refusalReason;
+exports.markToolRefusal = markToolRefusal;
+exports.toolRefusalOf = toolRefusalOf;
+exports.TOOL_ERROR_REASONS = [
+    /** An unexpected throw: a defect, not a refusal. */
+    'internal',
+    /** A refusal with no more specific code in this set. */
+    'refused',
+    /** A required argument was absent or empty. */
+    'missing_argument',
+    /** An argument was present but unusable as sent. */
+    'invalid_argument',
+    /** A scope was not `global`, `scope:<slug>` or `project:<slug>`. */
+    'invalid_scope',
+    /** A field was longer than the bound that stores it (memory/limits.ts, lifecycle FIELD_LIMITS). */
+    'field_too_long',
+    /** Text that cannot be stored or framed as text: control characters, an unpaired surrogate, a NUL byte. */
+    'invalid_text',
+    /** A path that escapes the memory directory, hides a segment, crosses a symlink, or is not a memory. */
+    'unsafe_path',
+    /** The memory id named nothing (it may have been retired). */
+    'memory_not_found',
+    /** That memory was already retired. */
+    'memory_already_retired',
+    /** A restore would overwrite a file that now occupies the path. */
+    'restore_conflict',
+    /** A write would take counted Markdown over the workspace plan ceiling. */
+    'storage_limit',
+    /** An import batch or preview is unknown or has expired. */
+    'batch_not_found',
+    /** The batch was already applied, failed or undone; it cannot be applied again. */
+    'batch_already_applied',
+    /** The batch was larger than the import byte bounds allow. */
+    'import_too_large',
+    /** A file the import would not admit (not a Markdown file). */
+    'unsupported_import_format',
+    /** The batch named the same relative path twice. */
+    'duplicate_import_path',
+    /** Too many previews are pending in this workspace; apply or wait for one to expire. */
+    'too_many_previews',
+    /** The deployment cannot answer this way right now (no semantic search, no keyword index, no history). */
+    'capability_unavailable',
+    /** The same, while the index is being rebuilt: it answers again once that finishes. */
+    'capability_rebuilding',
+    /** A search query the keyword index could not read as a query. */
+    'invalid_query',
+];
+/** The only gate a code passes to reach telemetry: membership in the closed set, nothing else. */
+function isToolErrorReason(value) {
+    return typeof value === 'string' && exports.TOOL_ERROR_REASONS.includes(value);
+}
+/**
+ * The code an error carries, out of band: a WeakMap leaves no property to serialize, so the error keeps the
+ * identity it had before this vocabulary existed — its class, `name`, `message` and enumerable keys — and the
+ * code reaches telemetry only. Nothing about `String(err)`, a log line or an `instanceof` check changes.
+ */
+const errorReasons = new WeakMap();
+/**
+ * Shorthand for the refusal sites: `throw refusal('invalid_scope', '…')`. The error is a PLAIN `Error`, exactly
+ * what the site threw before; only the message (unchanged) and the out-of-band code are kept.
+ */
+function refusal(reason, message) {
+    return markErrorReason(new Error(message), reason);
+}
+/** Records the code an error carries, out of band. Used by `refusal` and by an error class that names its own. */
+function markErrorReason(err, reason) {
+    errorReasons.set(err, reason);
+    return err;
+}
+/**
+ * The code an error carries, or undefined when it carries none.
+ *
+ * Read from the out-of-band WeakMap rather than a property, so an error class that already exists
+ * (LifecycleInputError, say) names its code without gaining a field and without losing its own identity to the
+ * callers that check `instanceof` — and no error ever grows a `reason` key a reply or a log line could show.
+ */
+function refusalReason(err) {
+    return err instanceof Error ? errorReasons.get(err) : undefined;
+}
+/**
+ * A tool result built by a refusal path carries its code here, beside the result and never inside it: a
+ * WeakMap leaves no property to serialize, so the code cannot ride out to the agent, into a log line or into
+ * a remote sink by accident. The tool wrapper reads it and the code goes to telemetry only.
+ */
+const reasons = new WeakMap();
+function markToolRefusal(result, reason) {
+    reasons.set(result, reason);
+    return result;
+}
+/** The code a refusal result carries, if any. */
+function toolRefusalOf(result) {
+    return result !== null && typeof result === 'object' ? reasons.get(result) : undefined;
+}

package/dist/watcher/watcher.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startWatcher = startWatcher;
+const chokidar_1 = __importDefault(require("chokidar"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const pipeline_1 = require("../indexer/pipeline");
+function loadIgnorePatterns(vaultPath) {
+    try {
+        const raw = fs_1.default.readFileSync(path_1.default.join(vaultPath, '.semanticignore'), 'utf8');
+        return raw.split('\n').map(l => l.trim()).filter(l => l && !l.startsWith('#'));
+    }
+    catch {
+        return [];
+    }
+}
+function isIgnored(filePath, vaultPath, patterns) {
+    const rel = path_1.default.relative(vaultPath, filePath);
+    return patterns.some(p => {
+        const clean = p.replace(/\/$/, '');
+        return rel === clean || rel.startsWith(clean + '/') || rel.includes('/' + clean + '/') || rel.endsWith('/' + clean);
+    });
+}
+// Below the vault, so a vault that itself sits under a folder of this name is still watched.
+const WALKER_SKIPS = /(^|[\\/])(\.trash|\.memory-index|node_modules)([\\/]|$)/;
+function startWatcher(vaultPath, db, options = {}) {
+    const ignorePatterns = loadIgnorePatterns(vaultPath);
+    const watcher = chokidar_1.default.watch(path_1.default.join(vaultPath, '**/*.md'), {
+        // The walker's rules, so the watcher never indexes what an index pass would leave out (retired notes under .trash,
+        // node_modules), and no symbolic link: the walker never lists one, and a link in the vault must not pull in a file
+        // outside it.
+        ignored: [/\.obsidian/, /\.semantic-memory/, (p) => WALKER_SKIPS.test(path_1.default.relative(vaultPath, p))],
+        followSymlinks: false,
+        persistent: true,
+        ignoreInitial: true,
+        awaitWriteFinish: { stabilityThreshold: 300, pollInterval: 100 },
+    });
+    const pending = new Map();
+    const handle = (filePath) => {
+        if (isIgnored(filePath, vaultPath, ignorePatterns))
+            return;
+        // The glob reports a link to a file as the file, and a FIFO named like a note as a note; the walker lists neither.
+        const st = fs_1.default.lstatSync(filePath, { throwIfNoEntry: false });
+        if (st && !st.isFile())
+            return;
+        if (pending.has(filePath))
+            clearTimeout(pending.get(filePath));
+        pending.set(filePath, setTimeout(async () => {
+            pending.delete(filePath);
+            try {
+                await (0, pipeline_1.indexFile)(db, filePath, options);
+                console.log(`[watcher] indexed: ${filePath}`);
+            }
+            catch (err) {
+                console.error(`[watcher] error:`, err);
+            }
+        }, 500));
+    };
+    watcher
+        .on('add', handle)
+        .on('change', handle)
+        .on('unlink', (filePath) => {
+        if (isIgnored(filePath, vaultPath, ignorePatterns))
+            return;
+        db.transaction(() => {
+            db.prepare('DELETE FROM relations WHERE source_note = ?').run(filePath);
+            db.prepare('DELETE FROM notes WHERE path = ?').run(filePath);
+        })();
+        console.log(`[watcher] removed: ${filePath}`);
+    });
+    return watcher;
+}

package/package.json

@@ -1,6 +1,122 @@
 {
   "name": "renor-engine",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "description": "Local-first semantic memory — indexing, multi-signal retrieval, MCP",
+  "main": "dist/cli.js",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "scripts": {
+    "build": "tsc && node -e \"require('node:fs').copyFileSync('src/memory/hiveNameHeader.cjs', 'dist/memory/hiveNameHeader.cjs')\"",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "dev": "tsx src/cli.ts",
+    "mvp": "node dist/mvp/cli.js",
+    "mvp:dev": "tsx src/mvp/cli.ts",
+    "import:memory": "tsx src/importing/cli.ts",
+    "test:mvp-artifact": "node scripts/ci/verify-mvp-artifact.mjs",
+    "eval:typecheck": "tsc -p tsconfig.public-eval.json",
+    "eval:retrieval": "tsx scripts/eval/score-retrieval.ts",
+    "eval:renor": "tsx scripts/eval/run-renorbench.ts",
+    "eval:renor:hash": "tsx scripts/eval/run-renorbench.ts --provider hash",
+    "eval:renor:product": "tsx scripts/eval/run-renorbench-product.ts",
+    "eval:renor:product:hash": "tsx scripts/eval/run-renorbench-product.ts --provider hash",
+    "eval:renor:product:v2:hash": "tsx scripts/eval/run-renorbench-product.ts --provider hash --suite v2",
+    "eval:renor:product:docs:hash": "tsx scripts/eval/run-renorbench-product.ts --provider hash --suite documents",
+    "eval:cache": "tsx scripts/eval/eval-cache.ts",
+    "eval:compare": "tsx scripts/eval/compare-runs.ts",
+    "eval:renorbench:baseline": "tsx scripts/eval/renorbench-baseline.ts",
+    "eval:renor:v2:generate": "tsx scripts/eval/generate-renorbench-v2.ts --write",
+    "eval:renor:docs:generate": "tsx scripts/eval/generate-renorbench-docs.ts --write",
+    "eval:analyze": "tsx scripts/eval/analyze-failures.ts",
+    "eval:longmem": "tsx scripts/eval/run-longmemeval.ts",
+    "eval:longmem:merge": "tsx scripts/eval/merge-longmemeval-shards.ts",
+    "eval:longmem:qa": "tsx scripts/eval/run-longmemeval-qa.ts",
+    "eval:longmem:qa:score": "tsx scripts/eval/score-longmemeval-qa.ts",
+    "eval:longmem:product": "tsx scripts/eval/run-longmemeval-product.ts",
+    "eval:longmem:sessions": "tsx scripts/eval/score-longmemeval-sessions.ts",
+    "eval:longmem:v2": "tsx scripts/eval/run-longmemeval-v2.ts",
+    "eval:longmem:v2:score": "tsx scripts/eval/score-longmemeval-v2.ts",
+    "eval:locomo": "tsx scripts/eval/locomo/run-retrieval.ts",
+    "eval:locomo:score": "python3 scripts/eval/locomo/score-locomo.py",
+    "eval:beam": "tsx scripts/eval/beam/run-retrieval.ts",
+    "eval:beam:score": "tsx scripts/eval/beam/score-nuggets.ts",
+    "eval:convomem:run": "tsx scripts/eval/convomem/run-convomem.ts",
+    "eval:convomem:score": "tsx scripts/eval/convomem/score-convomem.ts",
+    "eval:register": "tsx scripts/eval/register-run.ts",
+    "eval:progress": "tsx scripts/eval/progress.ts",
+    "prebuild": "node scripts/ci/stamp-build.mjs",
+    "prepack": "npm run build"
+  },
+  "bin": {
+    "renor-engine": "dist/cli.js"
+  },
+  "keywords": [
+    "renor",
+    "semantic-memory",
+    "mcp",
+    "embeddings",
+    "knowledge-graph"
+  ],
+  "homepage": "https://renor.cloud",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/patrickpassosb/renor-engine.git"
+  },
+  "bugs": {
+    "url": "https://github.com/patrickpassosb/renor-engine/issues"
+  },
+  "author": "Patrick Passos",
+  "license": "AGPL-3.0-only",
+  "type": "commonjs",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.31.0",
+    "@posthog/mcp": "0.21.0",
+    "better-sqlite3": "^12.8.0",
+    "chokidar": "^3.6.0",
+    "commander": "^14.0.3",
+    "express": "^5.2.1",
+    "gpt-tokenizer": "^3.4.0",
+    "gray-matter": "^4.0.3",
+    "openai": "^6.33.0",
+    "posthog-node": "5.54.1",
+    "sqlite-vec": "^0.1.8",
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
+    "@xenova/transformers": "^2.17.2",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/express": "^5.0.6",
+    "@types/node": "^25.9.8",
+    "@types/supertest": "^7.2.0",
+    "libpg-query": "17.7.4",
+    "supertest": "^7.3.0",
+    "tsx": "^4.23.15",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2"
+  },
+  "peerDependencies": {
+    "@xenova/transformers": "^2.17.2"
+  },
+  "peerDependenciesMeta": {
+    "@xenova/transformers": {
+      "optional": true
+    }
+  },
+  "overrides": {
+    "@xenova/transformers": {
+      "sharp": "0.35.5",
+      "onnxruntime-web": {
+        "onnx-proto": {
+          "protobufjs": "7.6.6"
+        }
+      }
+    }
+  },
+  "engines": {
+    "node": ">=22 <23"
+  }
+}