@prover-coder-ai/context-doc 1.0.10 → 1.0.11

package/dist/core/knowledge.js

@@ -33,11 +33,14 @@ const safeParseJson = (line) => {
     }
 };
 const metadataMatches = (metadata, locator) => {
+    const fallbackCwdOnly = locator.normalizedRepositoryUrl === locator.normalizedCwd;
     const repoMatches = Option.exists(metadata.repositoryUrl, (repositoryUrl) => normalizeRepositoryUrl(repositoryUrl) === locator.normalizedRepositoryUrl);
     const cwdMatches = Option.exists(metadata.cwd, (cwdValue) => {
         const normalized = normalizeCwd(cwdValue);
-        return (locator.normalizedCwd.startsWith(normalized) ||
-            normalized.startsWith(locator.normalizedCwd));
+        return fallbackCwdOnly
+            ? normalized === locator.normalizedCwd
+            : locator.normalizedCwd.startsWith(normalized) ||
+                normalized.startsWith(locator.normalizedCwd);
     });
     return repoMatches || cwdMatches;
 };

package/dist/shell/claudeSync.js

@@ -0,0 +1,23 @@
+import * as NodeFs from "node:fs";
+import * as NodeOs from "node:os";
+import * as NodePath from "node:path";
+import { Effect, pipe } from "effect";
+import { copyFilteredFiles, runSyncSource, syncError } from "./syncShared.js";
+const slugFromCwd = (cwd) => `-${cwd.replace(/^\/+/, "").replace(/\//g, "-")}`;
+const resolveClaudeProjectDir = (cwd, overrideProjectsRoot) => pipe(Effect.sync(() => {
+    const slug = slugFromCwd(cwd);
+    const base = overrideProjectsRoot ??
+        NodePath.join(NodeOs.homedir(), ".claude", "projects");
+    const candidate = NodePath.join(base, slug);
+    return NodeFs.existsSync(candidate) ? candidate : undefined;
+}), Effect.flatMap((found) => found === undefined
+    ? Effect.fail(syncError(".claude", "Claude project directory is missing"))
+    : Effect.succeed(found)));
+const copyClaudeJsonl = (sourceDir, destinationDir) => copyFilteredFiles(sourceDir, destinationDir, (entry, fullPath) => entry.isFile() && fullPath.endsWith(".jsonl"), "Cannot traverse Claude project");
+export const syncClaude = (options) => runSyncSource(claudeSource, options);
+const claudeSource = {
+    name: "Claude",
+    destSubdir: ".claude",
+    resolveSource: (options) => resolveClaudeProjectDir(options.cwd, options.claudeProjectsRoot),
+    copy: (sourceDir, destinationDir) => copyClaudeJsonl(sourceDir, destinationDir),
+};

package/dist/shell/qwenSync.js

@@ -2,29 +2,8 @@ import { createHash } from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { Console, Effect, pipe } from "effect";
-import { ensureDirectory, syncError } from "./syncShared.js";
-const copyDirectoryJsonOnly = (sourceRoot, destinationRoot) => Effect.try({
-    try: () => {
-        let copied = 0;
-        fs.cpSync(sourceRoot, destinationRoot, {
-            recursive: true,
-            filter: (src) => {
-                const stat = fs.statSync(src);
-                if (stat.isDirectory()) {
-                    return true;
-                }
-                if (src.endsWith(".json")) {
-                    copied += 1;
-                    return true;
-                }
-                return false;
-            },
-        });
-        return copied;
-    },
-    catch: () => syncError(sourceRoot, "Cannot traverse Qwen directory"),
-});
+import { Effect } from "effect";
+import { copyFilteredFiles, runSyncSource, syncError } from "./syncShared.js";
 const qwenHashFromPath = (projectPath) => createHash("sha256").update(projectPath).digest("hex");
 const resolveQwenSourceDir = (cwd, override, metaRoot) => Effect.gen(function* (_) {
     const hash = qwenHashFromPath(cwd);
@@ -53,14 +32,10 @@ const resolveQwenSourceDir = (cwd, override, metaRoot) => Effect.gen(function* (
     }
     return found;
 });
-export const syncQwen = (options) => pipe(resolveQwenSourceDir(options.cwd, options.qwenSourceDir, options.metaRoot), Effect.flatMap((qwenSource) => Effect.gen(function* (_) {
-    const destination = path.join(options.cwd, ".knowledge", ".qwen");
-    if (path.resolve(qwenSource) === path.resolve(destination)) {
-        yield* _(Console.log("Qwen source equals destination; skipping copy to avoid duplicates"));
-        return;
-    }
-    yield* _(ensureDirectory(destination));
-    const qwenRoot = path.dirname(path.dirname(qwenSource));
-    const copiedCount = yield* _(copyDirectoryJsonOnly(qwenSource, destination));
-    yield* _(Console.log(`Qwen: copied ${copiedCount} files from ${qwenRoot} to ${destination}`));
-})), Effect.catchAll((error) => Console.log(`Qwen source not found; skipped syncing Qwen dialog files (${error.reason})`)));
+export const syncQwen = (options) => runSyncSource(qwenSource, options);
+const qwenSource = {
+    name: "Qwen",
+    destSubdir: ".qwen",
+    resolveSource: (options) => resolveQwenSourceDir(options.cwd, options.qwenSourceDir, options.metaRoot),
+    copy: (sourceDir, destinationDir) => copyFilteredFiles(sourceDir, destinationDir, (entry, fullPath) => entry.isFile() && fullPath.endsWith(".json"), "Cannot traverse Qwen directory"),
+};

package/dist/shell/syncKnowledge.js

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
 import { Effect } from "effect";
+import { syncClaude } from "./claudeSync.js";
 import { syncCodex } from "./codexSync.js";
 import { syncQwen } from "./qwenSync.js";
 // PURPOSE: Sync project-scoped dialogs (Codex + Qwen) into .knowledge storage.
 export const buildSyncProgram = (options) => Effect.gen(function* (_) {
+    yield* _(syncClaude(options));
     yield* _(syncCodex(options));
     yield* _(syncQwen(options));
 });
@@ -19,6 +21,7 @@ export const parseArgs = () => {
         "--project-name": "repositoryUrlOverride",
         "--meta-root": "metaRoot",
         "--qwen-source": "qwenSourceDir",
+        "--claude-projects": "claudeProjectsRoot",
     };
     for (let i = 0; i < argv.length; i++) {
         const arg = argv[i];

package/dist/shell/syncShared.js

@@ -1,5 +1,7 @@
 import fs from "node:fs";
-import { Effect } from "effect";
+import path from "node:path";
+import { Console, Effect } from "effect";
+import { pipe } from "effect/Function";
 export const syncError = (pathValue, reason) => ({
     _tag: "SyncError",
     path: pathValue,
@@ -11,3 +13,37 @@ export const ensureDirectory = (directory) => Effect.try({
     },
     catch: () => syncError(directory, "Cannot create destination directory structure"),
 });
+export const runSyncSource = (source, options) => pipe(Effect.gen(function* (_) {
+    const resolvedSource = yield* _(source.resolveSource(options));
+    const destination = path.join(options.cwd, ".knowledge", source.destSubdir);
+    if (path.resolve(resolvedSource) === path.resolve(destination)) {
+        yield* _(Console.log(`${source.name}: source equals destination; skipping copy to avoid duplicates`));
+        return;
+    }
+    yield* _(ensureDirectory(destination));
+    const copied = yield* _(source.copy(resolvedSource, destination, options));
+    yield* _(Console.log(`${source.name}: copied ${copied} files from ${resolvedSource} to ${destination}`));
+}), Effect.catchAll((error) => Console.log(`${source.name}: source not found; skipped syncing (${error.reason})`)));
+export const copyFilteredFiles = (sourceRoot, destinationRoot, isRelevant, errorReason) => Effect.try({
+    try: () => {
+        let copied = 0;
+        const walk = (current) => {
+            const entries = fs.readdirSync(current, { withFileTypes: true });
+            for (const entry of entries) {
+                const full = path.join(current, entry.name);
+                if (entry.isDirectory()) {
+                    walk(full);
+                }
+                else if (isRelevant(entry, full)) {
+                    const target = path.join(destinationRoot, path.relative(sourceRoot, full));
+                    fs.mkdirSync(path.dirname(target), { recursive: true });
+                    fs.copyFileSync(full, target);
+                    copied += 1;
+                }
+            }
+        };
+        walk(sourceRoot);
+        return copied;
+    },
+    catch: () => syncError(sourceRoot, errorReason),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prover-coder-ai/context-doc",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "",
   "type": "module",
   "scripts": {
@@ -8,8 +8,9 @@
     "build": "tsc -p tsconfig.build.json",
     "lint": "npx --no-install @ton-ai-core/vibecode-linter src/",
     "test": "npx --no-install @ton-ai-core/vibecode-linter tests/ && vitest run --passWithNoTests",
+    "prepare": "git config core.hooksPath .githooks && chmod +x .githooks/pre-commit",
     "sync:knowledge": "npm run build && PKG=prover-coder-ai-context-doc-$(node -p \"require('./package.json').version\").tgz && rm -f \"$PKG\" && npm pack >/dev/null && npx -y -p \"./$PKG\" context-doc",
-    "release": "npm run build && npm run lint && npm version patch && npm publish --access public"
+    "release": "npm run lint && npm run build && npm version patch && npm publish --access public"
   },
   "bin": {
     "context-doc": "dist/shell/cli.js"

package/src/core/knowledge.ts

@@ -107,6 +107,9 @@ const metadataMatches = (
 	metadata: RecordMetadata,
 	locator: ProjectLocator,
 ): boolean => {
+	const fallbackCwdOnly =
+		locator.normalizedRepositoryUrl === locator.normalizedCwd;
+
 	const repoMatches = Option.exists(
 		metadata.repositoryUrl,
 		(repositoryUrl) =>
@@ -115,10 +118,10 @@ const metadataMatches = (
 
 	const cwdMatches = Option.exists(metadata.cwd, (cwdValue) => {
 		const normalized = normalizeCwd(cwdValue);
-		return (
-			locator.normalizedCwd.startsWith(normalized) ||
-			normalized.startsWith(locator.normalizedCwd)
-		);
+		return fallbackCwdOnly
+			? normalized === locator.normalizedCwd
+			: locator.normalizedCwd.startsWith(normalized) ||
+					normalized.startsWith(locator.normalizedCwd);
 	});
 
 	return repoMatches || cwdMatches;

package/src/shell/claudeSync.ts

@@ -0,0 +1,55 @@
+import * as NodeFs from "node:fs";
+import * as NodeOs from "node:os";
+import * as NodePath from "node:path";
+import { Effect, pipe } from "effect";
+import { copyFilteredFiles, runSyncSource, syncError } from "./syncShared.js";
+import type { SyncError, SyncOptions, SyncSource } from "./syncTypes.js";
+
+const slugFromCwd = (cwd: string): string =>
+	`-${cwd.replace(/^\/+/, "").replace(/\//g, "-")}`;
+
+const resolveClaudeProjectDir = (
+	cwd: string,
+	overrideProjectsRoot?: string,
+): Effect.Effect<string, SyncError> =>
+	pipe(
+		Effect.sync(() => {
+			const slug = slugFromCwd(cwd);
+			const base =
+				overrideProjectsRoot ??
+				NodePath.join(NodeOs.homedir(), ".claude", "projects");
+			const candidate = NodePath.join(base, slug);
+			return NodeFs.existsSync(candidate) ? candidate : undefined;
+		}),
+		Effect.flatMap((found) =>
+			found === undefined
+				? Effect.fail(
+						syncError(".claude", "Claude project directory is missing"),
+					)
+				: Effect.succeed(found),
+		),
+	);
+
+const copyClaudeJsonl = (
+	sourceDir: string,
+	destinationDir: string,
+): Effect.Effect<number, SyncError> =>
+	copyFilteredFiles(
+		sourceDir,
+		destinationDir,
+		(entry, fullPath) => entry.isFile() && fullPath.endsWith(".jsonl"),
+		"Cannot traverse Claude project",
+	);
+
+export const syncClaude = (
+	options: SyncOptions,
+): Effect.Effect<void, SyncError> => runSyncSource(claudeSource, options);
+
+const claudeSource: SyncSource = {
+	name: "Claude",
+	destSubdir: ".claude",
+	resolveSource: (options) =>
+		resolveClaudeProjectDir(options.cwd, options.claudeProjectsRoot),
+	copy: (sourceDir, destinationDir) =>
+		copyClaudeJsonl(sourceDir, destinationDir),
+};

package/src/shell/qwenSync.ts

@@ -2,35 +2,9 @@ import { createHash } from "node:crypto";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { Console, Effect, pipe } from "effect";
-import { ensureDirectory, syncError } from "./syncShared.js";
-import type { SyncError, SyncOptions } from "./syncTypes.js";
-
-const copyDirectoryJsonOnly = (
-	sourceRoot: string,
-	destinationRoot: string,
-): Effect.Effect<number, SyncError> =>
-	Effect.try({
-		try: () => {
-			let copied = 0;
-			fs.cpSync(sourceRoot, destinationRoot, {
-				recursive: true,
-				filter: (src) => {
-					const stat = fs.statSync(src);
-					if (stat.isDirectory()) {
-						return true;
-					}
-					if (src.endsWith(".json")) {
-						copied += 1;
-						return true;
-					}
-					return false;
-				},
-			});
-			return copied;
-		},
-		catch: () => syncError(sourceRoot, "Cannot traverse Qwen directory"),
-	});
+import { Effect } from "effect";
+import { copyFilteredFiles, runSyncSource, syncError } from "./syncShared.js";
+import type { SyncError, SyncOptions, SyncSource } from "./syncTypes.js";
 
 const qwenHashFromPath = (projectPath: string): string =>
 	createHash("sha256").update(projectPath).digest("hex");
@@ -82,36 +56,18 @@ const resolveQwenSourceDir = (
 
 export const syncQwen = (
 	options: SyncOptions,
-): Effect.Effect<void, SyncError> =>
-	pipe(
-		resolveQwenSourceDir(options.cwd, options.qwenSourceDir, options.metaRoot),
-		Effect.flatMap((qwenSource) =>
-			Effect.gen(function* (_) {
-				const destination = path.join(options.cwd, ".knowledge", ".qwen");
-				if (path.resolve(qwenSource) === path.resolve(destination)) {
-					yield* _(
-						Console.log(
-							"Qwen source equals destination; skipping copy to avoid duplicates",
-						),
-					);
-					return;
-				}
+): Effect.Effect<void, SyncError> => runSyncSource(qwenSource, options);
 
-				yield* _(ensureDirectory(destination));
-				const qwenRoot = path.dirname(path.dirname(qwenSource));
-				const copiedCount = yield* _(
-					copyDirectoryJsonOnly(qwenSource, destination),
-				);
-				yield* _(
-					Console.log(
-						`Qwen: copied ${copiedCount} files from ${qwenRoot} to ${destination}`,
-					),
-				);
-			}),
-		),
-		Effect.catchAll((error) =>
-			Console.log(
-				`Qwen source not found; skipped syncing Qwen dialog files (${error.reason})`,
-			),
+const qwenSource: SyncSource = {
+	name: "Qwen",
+	destSubdir: ".qwen",
+	resolveSource: (options) =>
+		resolveQwenSourceDir(options.cwd, options.qwenSourceDir, options.metaRoot),
+	copy: (sourceDir, destinationDir) =>
+		copyFilteredFiles(
+			sourceDir,
+			destinationDir,
+			(entry, fullPath) => entry.isFile() && fullPath.endsWith(".json"),
+			"Cannot traverse Qwen directory",
 		),
-	);
+};

package/src/shell/syncKnowledge.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { Effect } from "effect";
+import { syncClaude } from "./claudeSync.js";
 import { syncCodex } from "./codexSync.js";
 import { syncQwen } from "./qwenSync.js";
 import type { SyncError, SyncOptions } from "./syncTypes.js";
@@ -9,6 +10,7 @@ export const buildSyncProgram = (
 	options: SyncOptions,
 ): Effect.Effect<void, SyncError> =>
 	Effect.gen(function* (_) {
+		yield* _(syncClaude(options));
 		yield* _(syncCodex(options));
 		yield* _(syncQwen(options));
 	});
@@ -26,6 +28,7 @@ export const parseArgs = (): SyncOptions => {
 		"--project-name": "repositoryUrlOverride",
 		"--meta-root": "metaRoot",
 		"--qwen-source": "qwenSourceDir",
+		"--claude-projects": "claudeProjectsRoot",
 	};
 
 	for (let i = 0; i < argv.length; i++) {

package/src/shell/syncShared.ts

@@ -1,6 +1,8 @@
 import fs from "node:fs";
-import { Effect } from "effect";
-import type { SyncError } from "./syncTypes.js";
+import path from "node:path";
+import { Console, Effect } from "effect";
+import { pipe } from "effect/Function";
+import type { SyncError, SyncOptions, SyncSource } from "./syncTypes.js";
 
 export const syncError = (pathValue: string, reason: string): SyncError => ({
 	_tag: "SyncError",
@@ -18,3 +20,75 @@ export const ensureDirectory = (
 		catch: () =>
 			syncError(directory, "Cannot create destination directory structure"),
 	});
+
+export const runSyncSource = (
+	source: SyncSource,
+	options: SyncOptions,
+): Effect.Effect<void, SyncError> =>
+	pipe(
+		Effect.gen(function* (_) {
+			const resolvedSource = yield* _(source.resolveSource(options));
+			const destination = path.join(
+				options.cwd,
+				".knowledge",
+				source.destSubdir,
+			);
+
+			if (path.resolve(resolvedSource) === path.resolve(destination)) {
+				yield* _(
+					Console.log(
+						`${source.name}: source equals destination; skipping copy to avoid duplicates`,
+					),
+				);
+				return;
+			}
+
+			yield* _(ensureDirectory(destination));
+			const copied = yield* _(
+				source.copy(resolvedSource, destination, options),
+			);
+			yield* _(
+				Console.log(
+					`${source.name}: copied ${copied} files from ${resolvedSource} to ${destination}`,
+				),
+			);
+		}),
+		Effect.catchAll((error: SyncError) =>
+			Console.log(
+				`${source.name}: source not found; skipped syncing (${error.reason})`,
+			),
+		),
+	);
+
+export const copyFilteredFiles = (
+	sourceRoot: string,
+	destinationRoot: string,
+	isRelevant: (entry: fs.Dirent, fullPath: string) => boolean,
+	errorReason: string,
+): Effect.Effect<number, SyncError> =>
+	Effect.try({
+		try: () => {
+			let copied = 0;
+			const walk = (current: string): void => {
+				const entries = fs.readdirSync(current, { withFileTypes: true });
+				for (const entry of entries) {
+					const full = path.join(current, entry.name);
+					if (entry.isDirectory()) {
+						walk(full);
+					} else if (isRelevant(entry, full)) {
+						const target = path.join(
+							destinationRoot,
+							path.relative(sourceRoot, full),
+						);
+						fs.mkdirSync(path.dirname(target), { recursive: true });
+						fs.copyFileSync(full, target);
+						copied += 1;
+					}
+				}
+			};
+
+			walk(sourceRoot);
+			return copied;
+		},
+		catch: () => syncError(sourceRoot, errorReason),
+	});

package/src/shell/syncTypes.ts

@@ -1,3 +1,5 @@
+import type * as Fx from "effect";
+
 export interface SyncError {
 	readonly _tag: "SyncError";
 	readonly path: string;
@@ -11,4 +13,18 @@ export interface SyncOptions {
 	readonly repositoryUrlOverride?: string;
 	readonly metaRoot?: string;
 	readonly qwenSourceDir?: string;
+	readonly claudeProjectsRoot?: string;
+}
+
+type SyncEffect<A> = Fx.Effect.Effect<A, SyncError>;
+
+export interface SyncSource {
+	readonly name: string;
+	readonly destSubdir: ".codex" | ".qwen" | ".claude";
+	readonly resolveSource: (options: SyncOptions) => SyncEffect<string>;
+	readonly copy: (
+		sourceDir: string,
+		destinationDir: string,
+		options: SyncOptions,
+	) => SyncEffect<number>;
 }