@byterover/claude-plugin 1.0.0

package/dist/memory-path.js

@@ -0,0 +1,214 @@
+import { readFileSync, realpathSync, statSync, } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, normalize, resolve, sep, } from "node:path";
+// ---------------------------------------------------------------------------
+// djb2 hash — exact match of cc-ts/utils/hash.ts
+// ---------------------------------------------------------------------------
+function djb2Hash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        hash = ((hash << 5) - hash + str.charCodeAt(i)) | 0;
+    }
+    return hash;
+}
+function simpleHash(str) {
+    return Math.abs(djb2Hash(str)).toString(36);
+}
+// ---------------------------------------------------------------------------
+// Path sanitization — exact match of cc-ts/utils/sessionStoragePortable.ts
+// ---------------------------------------------------------------------------
+const MAX_SANITIZED_LENGTH = 200;
+export function sanitizePath(name) {
+    const sanitized = name.replace(/[^a-zA-Z0-9]/g, "-");
+    if (sanitized.length <= MAX_SANITIZED_LENGTH) {
+        return sanitized;
+    }
+    return `${sanitized.slice(0, MAX_SANITIZED_LENGTH)}-${simpleHash(name)}`;
+}
+// ---------------------------------------------------------------------------
+// Claude config home
+// ---------------------------------------------------------------------------
+export function getClaudeConfigHome() {
+    return (process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude")).normalize("NFC");
+}
+// ---------------------------------------------------------------------------
+// Memory base directory
+// ---------------------------------------------------------------------------
+function getMemoryBaseDir() {
+    return process.env.CLAUDE_CODE_REMOTE_MEMORY_DIR ?? getClaudeConfigHome();
+}
+// ---------------------------------------------------------------------------
+// Memory path validation — matches cc-ts/memdir/paths.ts validateMemoryPath
+// ---------------------------------------------------------------------------
+function validateMemoryPath(raw, expandTilde) {
+    if (!raw || typeof raw !== "string")
+        return undefined;
+    let candidate = raw;
+    // Expand ~/ if allowed (settings: yes, env var: no)
+    if (expandTilde &&
+        (candidate.startsWith("~/") || candidate.startsWith("~\\"))) {
+        candidate = join(homedir(), candidate.slice(2));
+    }
+    // Normalize and strip trailing separators
+    const normalized = normalize(candidate).replace(/[/\\]+$/, "");
+    // Reject non-absolute, too short, or dangerous paths
+    if (!isAbsolute(normalized))
+        return undefined;
+    if (normalized.length < 3)
+        return undefined;
+    if (normalized.includes("\0"))
+        return undefined;
+    // Reject UNC paths on Windows
+    if (normalized.startsWith("\\\\"))
+        return undefined;
+    // Reject paths that resolve to home dir, its parent, or root-like dirs.
+    // A malicious settings file with autoMemoryDirectory: "~/.." would otherwise
+    // redirect bridge writes to /Users/ (or equivalent).
+    const home = homedir();
+    const homeParent = dirname(home);
+    if (normalized === home ||
+        normalized === homeParent ||
+        normalized === dirname(homeParent)) {
+        return undefined;
+    }
+    return (normalized + sep).normalize("NFC");
+}
+// ---------------------------------------------------------------------------
+// Settings-based override — best local approximation of cc-ts precedence
+// ---------------------------------------------------------------------------
+function readAutoMemDirFromSettings(filePath) {
+    try {
+        const content = readFileSync(filePath, "utf-8");
+        const settings = JSON.parse(content);
+        if (typeof settings.autoMemoryDirectory === "string" &&
+            settings.autoMemoryDirectory) {
+            return settings.autoMemoryDirectory;
+        }
+    }
+    catch {
+        // file doesn't exist or isn't valid JSON
+    }
+    return undefined;
+}
+function getAutoMemPathSetting(cwd) {
+    // Best local approximation of cc-ts precedence:
+    //   policySettings → flagSettings → localSettings → userSettings
+    // We cannot access policySettings or flagSettings from a hook process.
+    // Env-var overrides (priority 1 & 2) cover those cases in practice.
+    // localSettings: <cwd>/.claude/settings.local.json
+    const localDir = readAutoMemDirFromSettings(join(cwd, ".claude", "settings.local.json"));
+    if (localDir)
+        return validateMemoryPath(localDir, true);
+    // userSettings: ~/.claude/settings.json
+    const userDir = readAutoMemDirFromSettings(join(getClaudeConfigHome(), "settings.json"));
+    if (userDir)
+        return validateMemoryPath(userDir, true);
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Full override via env var
+// ---------------------------------------------------------------------------
+function getAutoMemPathOverride() {
+    const raw = process.env.CLAUDE_COWORK_MEMORY_PATH_OVERRIDE;
+    return validateMemoryPath(raw, false);
+}
+// ---------------------------------------------------------------------------
+// Canonical git root — walk up, follow worktree chain
+// Ported from cc-ts/utils/git.ts
+// ---------------------------------------------------------------------------
+function findGitRoot(startPath) {
+    let current = resolve(startPath);
+    const root = current.substring(0, current.indexOf(sep) + 1) || sep;
+    while (current !== root) {
+        try {
+            const gitPath = join(current, ".git");
+            const st = statSync(gitPath);
+            if (st.isDirectory() || st.isFile()) {
+                return current.normalize("NFC");
+            }
+        }
+        catch {
+            // .git doesn't exist here
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    // Check root
+    try {
+        const st = statSync(join(root, ".git"));
+        if (st.isDirectory() || st.isFile()) {
+            return root.normalize("NFC");
+        }
+    }
+    catch {
+        // not in git
+    }
+    return null;
+}
+function resolveCanonicalRoot(gitRoot) {
+    try {
+        const gitContent = readFileSync(join(gitRoot, ".git"), "utf-8").trim();
+        if (!gitContent.startsWith("gitdir:")) {
+            return gitRoot;
+        }
+        const worktreeGitDir = resolve(gitRoot, gitContent.slice("gitdir:".length).trim());
+        // commondir → shared .git directory. Submodules have none → falls through.
+        const commonDir = resolve(worktreeGitDir, readFileSync(join(worktreeGitDir, "commondir"), "utf-8").trim());
+        // Security: validate worktree chain structure
+        if (resolve(dirname(worktreeGitDir)) !== join(commonDir, "worktrees")) {
+            return gitRoot;
+        }
+        const backlink = realpathSync(readFileSync(join(worktreeGitDir, "gitdir"), "utf-8").trim());
+        if (backlink !== join(realpathSync(gitRoot), ".git")) {
+            return gitRoot;
+        }
+        // Bare-repo worktrees: common dir isn't inside a working directory
+        if (basename(commonDir) !== ".git") {
+            return commonDir.normalize("NFC");
+        }
+        return dirname(commonDir).normalize("NFC");
+    }
+    catch {
+        return gitRoot;
+    }
+}
+export function findCanonicalGitRoot(startPath) {
+    const root = findGitRoot(startPath);
+    if (!root)
+        return null;
+    return resolveCanonicalRoot(root);
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Resolve the Claude Code auto-memory directory for a given project cwd.
+ * Matches cc-ts resolution priority:
+ *   1. CLAUDE_COWORK_MEMORY_PATH_OVERRIDE env var
+ *   2. autoMemoryDirectory from settings (local → user)
+ *   3. <memoryBase>/projects/<sanitized-git-root>/memory/
+ */
+export function getCcMemoryDir(cwd) {
+    // Priority 1: full path override
+    const override = getAutoMemPathOverride();
+    if (override)
+        return override;
+    // Priority 2: settings override
+    const setting = getAutoMemPathSetting(cwd);
+    if (setting)
+        return setting;
+    // Priority 3: computed from canonical git root
+    const gitRoot = findCanonicalGitRoot(cwd) ?? cwd;
+    const projectsDir = join(getMemoryBaseDir(), "projects");
+    return (join(projectsDir, sanitizePath(gitRoot), "memory") + sep).normalize("NFC");
+}
+/**
+ * Check if a file path is inside a cc-ts memory directory.
+ * Takes pre-resolved memoryDir for efficiency and clarity.
+ */
+export function isCcMemoryPath(filePath, memoryDir) {
+    return filePath.startsWith(memoryDir);
+}
+//# sourceMappingURL=memory-path.js.map

package/dist/schemas/cc-hook-input.d.ts

@@ -0,0 +1,129 @@
+import { z } from "zod";
+/**
+ * Schema for the JSON that Claude Code pipes to hook commands via stdin.
+ * Matches upstream: cc-ts/entrypoints/sdk/coreSchemas.ts
+ */
+export declare const BaseHookInputSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    transcript_path: z.ZodString;
+    cwd: z.ZodString;
+    permission_mode: z.ZodOptional<z.ZodString>;
+    agent_id: z.ZodOptional<z.ZodString>;
+    agent_type: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    session_id: string;
+    transcript_path: string;
+    cwd: string;
+    permission_mode?: string | undefined;
+    agent_id?: string | undefined;
+    agent_type?: string | undefined;
+}, {
+    session_id: string;
+    transcript_path: string;
+    cwd: string;
+    permission_mode?: string | undefined;
+    agent_id?: string | undefined;
+    agent_type?: string | undefined;
+}>;
+export declare const PostToolUseHookInputSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    transcript_path: z.ZodString;
+    cwd: z.ZodString;
+    permission_mode: z.ZodOptional<z.ZodString>;
+    agent_id: z.ZodOptional<z.ZodString>;
+    agent_type: z.ZodOptional<z.ZodString>;
+} & {
+    hook_event_name: z.ZodLiteral<"PostToolUse">;
+    tool_name: z.ZodString;
+    tool_input: z.ZodUnknown;
+    tool_response: z.ZodUnknown;
+    tool_use_id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    session_id: string;
+    transcript_path: string;
+    cwd: string;
+    hook_event_name: "PostToolUse";
+    tool_name: string;
+    tool_use_id: string;
+    permission_mode?: string | undefined;
+    agent_id?: string | undefined;
+    agent_type?: string | undefined;
+    tool_input?: unknown;
+    tool_response?: unknown;
+}, {
+    session_id: string;
+    transcript_path: string;
+    cwd: string;
+    hook_event_name: "PostToolUse";
+    tool_name: string;
+    tool_use_id: string;
+    permission_mode?: string | undefined;
+    agent_id?: string | undefined;
+    agent_type?: string | undefined;
+    tool_input?: unknown;
+    tool_response?: unknown;
+}>;
+export declare const StopHookInputSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    transcript_path: z.ZodString;
+    cwd: z.ZodString;
+    permission_mode: z.ZodOptional<z.ZodString>;
+    agent_id: z.ZodOptional<z.ZodString>;
+    agent_type: z.ZodOptional<z.ZodString>;
+} & {
+    hook_event_name: z.ZodLiteral<"Stop">;
+    stop_hook_active: z.ZodBoolean;
+    last_assistant_message: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    session_id: string;
+    transcript_path: string;
+    cwd: string;
+    hook_event_name: "Stop";
+    stop_hook_active: boolean;
+    permission_mode?: string | undefined;
+    agent_id?: string | undefined;
+    agent_type?: string | undefined;
+    last_assistant_message?: string | undefined;
+}, {
+    session_id: string;
+    transcript_path: string;
+    cwd: string;
+    hook_event_name: "Stop";
+    stop_hook_active: boolean;
+    permission_mode?: string | undefined;
+    agent_id?: string | undefined;
+    agent_type?: string | undefined;
+    last_assistant_message?: string | undefined;
+}>;
+export declare const UserPromptSubmitHookInputSchema: z.ZodObject<{
+    session_id: z.ZodString;
+    transcript_path: z.ZodString;
+    cwd: z.ZodString;
+    permission_mode: z.ZodOptional<z.ZodString>;
+    agent_id: z.ZodOptional<z.ZodString>;
+    agent_type: z.ZodOptional<z.ZodString>;
+} & {
+    hook_event_name: z.ZodLiteral<"UserPromptSubmit">;
+    prompt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    session_id: string;
+    transcript_path: string;
+    cwd: string;
+    hook_event_name: "UserPromptSubmit";
+    prompt: string;
+    permission_mode?: string | undefined;
+    agent_id?: string | undefined;
+    agent_type?: string | undefined;
+}, {
+    session_id: string;
+    transcript_path: string;
+    cwd: string;
+    hook_event_name: "UserPromptSubmit";
+    prompt: string;
+    permission_mode?: string | undefined;
+    agent_id?: string | undefined;
+    agent_type?: string | undefined;
+}>;
+export type PostToolUseHookInput = z.infer<typeof PostToolUseHookInputSchema>;
+export type StopHookInput = z.infer<typeof StopHookInputSchema>;
+export type UserPromptSubmitHookInput = z.infer<typeof UserPromptSubmitHookInputSchema>;

package/dist/schemas/cc-hook-input.js

@@ -0,0 +1,30 @@
+import { z } from "zod";
+/**
+ * Schema for the JSON that Claude Code pipes to hook commands via stdin.
+ * Matches upstream: cc-ts/entrypoints/sdk/coreSchemas.ts
+ */
+export const BaseHookInputSchema = z.object({
+    session_id: z.string(),
+    transcript_path: z.string(),
+    cwd: z.string(),
+    permission_mode: z.string().optional(),
+    agent_id: z.string().optional(),
+    agent_type: z.string().optional(),
+});
+export const PostToolUseHookInputSchema = BaseHookInputSchema.extend({
+    hook_event_name: z.literal("PostToolUse"),
+    tool_name: z.string(),
+    tool_input: z.unknown(),
+    tool_response: z.unknown(),
+    tool_use_id: z.string(),
+});
+export const StopHookInputSchema = BaseHookInputSchema.extend({
+    hook_event_name: z.literal("Stop"),
+    stop_hook_active: z.boolean(),
+    last_assistant_message: z.string().optional(),
+});
+export const UserPromptSubmitHookInputSchema = BaseHookInputSchema.extend({
+    hook_event_name: z.literal("UserPromptSubmit"),
+    prompt: z.string(),
+});
+//# sourceMappingURL=cc-hook-input.js.map

package/dist/schemas/cc-settings.d.ts

@@ -0,0 +1,24 @@
+export interface BridgeCommandHook {
+    type: "command";
+    command: string;
+    async: boolean;
+    timeout: number;
+}
+export interface BridgeHookEntry {
+    matcher?: string;
+    hooks: BridgeCommandHook[];
+}
+/**
+ * Read settings.json as a raw JSON object. Returns empty object if missing.
+ * Never validates with Zod — preserves all upstream fields verbatim.
+ */
+export declare function readSettingsRaw(path: string): Record<string, unknown>;
+/**
+ * Write settings.json, preserving formatting.
+ * Creates parent directories if needed.
+ */
+export declare function writeSettingsRaw(path: string, data: Record<string, unknown>): void;
+/**
+ * Backup settings.json before modification.
+ */
+export declare function backupSettings(path: string): string;

package/dist/schemas/cc-settings.js

@@ -0,0 +1,35 @@
+import { existsSync, readFileSync, writeFileSync, copyFileSync, mkdirSync, } from "node:fs";
+import { dirname } from "node:path";
+// ---------------------------------------------------------------------------
+// Raw JSON read/write — preserves all unknown fields
+// ---------------------------------------------------------------------------
+/**
+ * Read settings.json as a raw JSON object. Returns empty object if missing.
+ * Never validates with Zod — preserves all upstream fields verbatim.
+ */
+export function readSettingsRaw(path) {
+    if (!existsSync(path)) {
+        return {};
+    }
+    const content = readFileSync(path, "utf-8");
+    return JSON.parse(content);
+}
+/**
+ * Write settings.json, preserving formatting.
+ * Creates parent directories if needed.
+ */
+export function writeSettingsRaw(path, data) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+/**
+ * Backup settings.json before modification.
+ */
+export function backupSettings(path) {
+    const backupPath = path + ".brv-backup";
+    if (existsSync(path)) {
+        copyFileSync(path, backupPath);
+    }
+    return backupPath;
+}
+//# sourceMappingURL=cc-settings.js.map

package/dist/stdin.d.ts

@@ -0,0 +1,7 @@
+import type { ZodSchema } from "zod";
+/**
+ * Read all data from stdin, parse as JSON, and validate with a Zod schema.
+ * Used by hook commands (ingest, sync) to read the JSON that Claude Code
+ * pipes to hook processes.
+ */
+export declare function readStdinJson<T>(schema: ZodSchema<T>): Promise<T>;

package/dist/stdin.js

@@ -0,0 +1,24 @@
+/**
+ * Read all data from stdin, parse as JSON, and validate with a Zod schema.
+ * Used by hook commands (ingest, sync) to read the JSON that Claude Code
+ * pipes to hook processes.
+ */
+export async function readStdinJson(schema) {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    const raw = Buffer.concat(chunks).toString("utf8").trim();
+    if (!raw) {
+        throw new Error("No input received on stdin");
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`Invalid JSON on stdin: ${raw.slice(0, 200)}`);
+    }
+    return schema.parse(parsed);
+}
+//# sourceMappingURL=stdin.js.map

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@byterover/claude-plugin",
+  "version": "1.0.0",
+  "description": "Native bridge between ByteRover context engine and Claude Code — enriches Claude's auto-memory with BM25-ranked knowledge from brv context tree",
+  "type": "module",
+  "bin": {
+    "brv-claude-plugin": "./dist/cli.js"
+  },
+  "main": "./dist/cli.js",
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "dev": "tsx src/cli.ts",
+    "test": "vitest run --dir test",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src/",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@byterover/brv-bridge": "^1.0.2",
+    "commander": "^13.0.0",
+    "js-yaml": "^4.1.0",
+    "picocolors": "^1.1.0",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.0",
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "keywords": [
+    "byterover",
+    "claude-code",
+    "memory",
+    "context-engine",
+    "bridge"
+  ],
+  "author": "ByteRover",
+  "license": "Elastic-2.0",
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/campfirein/brv-claude-plugin.git"
+  },
+  "homepage": "https://github.com/campfirein/brv-claude-plugin#readme",
+  "bugs": {
+    "url": "https://github.com/campfirein/brv-claude-plugin/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}