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

package/tests/shell/sync-knowledge.test.ts

@@ -0,0 +1,203 @@
+import { NodeContext } from "@effect/platform-node"
+import type * as FileSystem from "@effect/platform/FileSystem"
+import * as Path from "@effect/platform/Path"
+import { describe, expect, it } from "@effect/vitest"
+import { Effect, Layer, Option, pipe } from "effect"
+import fc from "fast-check"
+
+import { CryptoService, CryptoServiceLive } from "../../src/shell/services/crypto.js"
+import { FileSystemLive } from "../../src/shell/services/file-system.js"
+import { RuntimeEnv } from "../../src/shell/services/runtime-env.js"
+import { buildSyncProgram } from "../../src/shell/sync/index.js"
+import { buildTestPaths, makeTempDir, withFsPath, writeFile } from "../support/fs-helpers.js"
+
+const forEach = Effect.forEach
+const some = Option.some
+const mapFileEntry = (
+  sessionDir: string,
+  fs: FileSystem.FileSystem,
+  path: Path.Path
+) =>
+(entry: string) =>
+  pipe(
+    fs.stat(path.join(sessionDir, entry)),
+    Effect.map((info) => info.type === "File" ? some(entry) : Option.none())
+  )
+
+const testPaths = buildTestPaths(
+  new URL(import.meta.url),
+  "context-doc-tests"
+)
+
+const withTempDir = Effect.gen(function*(_) {
+  const { tempBase } = yield* _(testPaths)
+  return yield* _(makeTempDir(tempBase, "context-doc-"))
+})
+
+const makeRuntimeEnvLayer = (cwd: string): Layer.Layer<RuntimeEnv> =>
+  Layer.succeed(RuntimeEnv, {
+    argv: Effect.succeed(["node", "main"]),
+    cwd: Effect.succeed(cwd),
+    homedir: Effect.succeed(cwd),
+    envVar: () => Effect.succeed(Option.none())
+  })
+
+const assertSyncOutput = (
+  destDir: string,
+  qwenHash: string,
+  cwd: string,
+  expectedMessage: string,
+  skippedMessage: string
+) =>
+  withFsPath((fs, path) =>
+    Effect.gen(function*(_) {
+      const sessionDir = path.join(destDir, "sessions/2025/11")
+      const entries = yield* _(fs.readDirectory(sessionDir))
+      const files = yield* _(
+        forEach(entries, mapFileEntry(sessionDir, fs, path))
+      )
+      const copiedFiles = files.flatMap((entry) => Option.isSome(entry) ? [entry.value] : [])
+
+      expect(copiedFiles).toEqual(["match.jsonl"])
+
+      const content = yield* _(
+        fs.readFileString(path.join(sessionDir, "match.jsonl"))
+      )
+
+      expect(content).toContain(`"message":"${expectedMessage}"`)
+      expect(content).not.toContain(`"message":"${skippedMessage}"`)
+
+      const qwenCopied = path.join(
+        cwd,
+        ".knowledge",
+        ".qwen",
+        qwenHash,
+        "chats",
+        "session-1.json"
+      )
+
+      const exists = yield* _(fs.exists(qwenCopied))
+      expect(exists).toBe(true)
+    })
+  )
+
+const runSyncScenario = (
+  matchMessage: string,
+  skippedMessage: string
+) =>
+  Effect.scoped(
+    Effect.gen(function*(_) {
+      const path = yield* _(Path.Path)
+      const crypto = yield* _(CryptoService)
+      const cwd = yield* _(withTempDir)
+      const codexDir = path.join(cwd, ".codex")
+      const destDir = path.join(cwd, ".knowledge", ".codex")
+      const qwenSource = path.join(cwd, ".qwen", "tmp")
+      const qwenHash = yield* _(crypto.sha256(cwd))
+      yield* _(
+        writeFile(
+          path.join(codexDir, "sessions/2025/11/match.jsonl"),
+          [
+            JSON.stringify({ cwd, message: matchMessage }),
+            JSON.stringify({
+              payload: { cwd: path.join(cwd, "sub") }
+            })
+          ].join("\n")
+        )
+      )
+
+      yield* _(
+        writeFile(
+          path.join(codexDir, "sessions/2025/11/ignore.jsonl"),
+          [
+            JSON.stringify({
+              cwd: "/home/user/other",
+              message: skippedMessage
+            })
+          ].join("\n")
+        )
+      )
+
+      yield* _(
+        writeFile(
+          path.join(qwenSource, qwenHash, "chats", "session-1.json"),
+          JSON.stringify({ sessionId: "s1", projectHash: qwenHash })
+        )
+      )
+
+      yield* _(
+        Effect.provide(
+          buildSyncProgram({
+            cwd,
+            sourceDir: codexDir,
+            destinationDir: destDir,
+            qwenSourceDir: qwenSource
+          }),
+          Layer.mergeAll(FileSystemLive, makeRuntimeEnvLayer(cwd))
+        )
+      )
+
+      yield* _(assertSyncOutput(destDir, qwenHash, cwd, matchMessage, skippedMessage))
+    })
+  ).pipe(
+    Effect.provide(Layer.mergeAll(NodeContext.layer, CryptoServiceLive))
+  )
+
+describe("sync-knowledge end-to-end", () => {
+  const safeChar = fc.constantFrom(
+    "a",
+    "b",
+    "c",
+    "d",
+    "e",
+    "f",
+    "g",
+    "h",
+    "i",
+    "j",
+    "k",
+    "l",
+    "m",
+    "n",
+    "o",
+    "p",
+    "q",
+    "r",
+    "s",
+    "t",
+    "u",
+    "v",
+    "w",
+    "x",
+    "y",
+    "z",
+    "0",
+    "1",
+    "2",
+    "3",
+    "4",
+    "5"
+  )
+  const message: fc.Arbitrary<string> = fc.string({
+    minLength: 1,
+    maxLength: 12,
+    unit: safeChar
+  })
+  const messagePair: fc.Arbitrary<[string, string]> = fc
+    .tuple(message, message)
+    .filter((pair) => pair[0] !== pair[1])
+
+  it.effect("copies matching Codex files and Qwen json", () =>
+    Effect.tryPromise({
+      try: () =>
+        fc.assert(
+          fc.asyncProperty(
+            messagePair,
+            ([matchMessage, skippedMessage]: [string, string]) =>
+              Effect.runPromise(runSyncScenario(matchMessage, skippedMessage))
+          ),
+          { numRuns: 5 }
+        ),
+      catch: (error) => error instanceof Error ? error : new Error(String(error))
+    }))
+})

package/tests/support/fs-helpers.ts

@@ -0,0 +1,50 @@
+import * as FileSystem from "@effect/platform/FileSystem"
+import * as Path from "@effect/platform/Path"
+import { Effect, pipe } from "effect"
+
+const accessFsPath = Effect.gen(function*(_) {
+  const fs = yield* _(FileSystem.FileSystem)
+  const path = yield* _(Path.Path)
+  return { fs, path }
+})
+
+export const withFsPath = <A, E, R>(
+  fn: (fs: FileSystem.FileSystem, path: Path.Path) => Effect.Effect<A, E, R>
+): Effect.Effect<A, E, FileSystem.FileSystem | Path.Path | R> =>
+  pipe(
+    accessFsPath,
+    Effect.flatMap(({ fs, path }) => fn(fs, path))
+  )
+
+export const writeFile = (filePath: string, content: string) =>
+  withFsPath((fs, path) =>
+    Effect.gen(function*(_) {
+      yield* _(fs.makeDirectory(path.dirname(filePath), { recursive: true }))
+      yield* _(fs.writeFileString(filePath, content))
+    })
+  )
+
+export const makeTempDir = (base: string, prefix: string) =>
+  withFsPath((fs, _path) =>
+    Effect.gen(function*(_) {
+      yield* _(fs.makeDirectory(base, { recursive: true }))
+      return yield* _(fs.makeTempDirectoryScoped({ directory: base, prefix }))
+    })
+  )
+
+export const buildTestPaths = (
+  testUrl: URL,
+  tempName: string,
+  packName?: string
+) =>
+  Effect.gen(function*(_) {
+    const path = yield* _(Path.Path)
+    const testFile = yield* _(path.fromFileUrl(testUrl))
+    const testRoot = path.dirname(testFile)
+    const projectRoot = path.resolve(testRoot, "../../../..")
+    const tempBase = path.join(projectRoot, ".tmp", tempName)
+    const packBase = packName === undefined
+      ? undefined
+      : path.join(projectRoot, ".tmp", packName)
+    return { projectRoot, tempBase, packBase }
+  })

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+	"extends": "../../tsconfig.base.json",
+	"compilerOptions": {
+		"rootDir": ".",
+		"outDir": "dist",
+		"types": ["vitest"],
+		"baseUrl": ".",
+		"paths": {
+			"@/*": ["src/*"]
+		}
+	},
+	"include": [
+		"src/**/*",
+		"tests/**/*",
+		"vite.config.ts",
+		"vitest.config.ts"
+	],
+	"exclude": ["dist", "node_modules"]
+}

package/vite.config.ts

@@ -0,0 +1,32 @@
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import { defineConfig } from "vite"
+import tsconfigPaths from "vite-tsconfig-paths"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+export default defineConfig({
+  plugins: [tsconfigPaths()],
+  publicDir: false,
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "src")
+    }
+  },
+  build: {
+    target: "node20",
+    outDir: "dist",
+    sourcemap: true,
+    ssr: "src/app/main.ts",
+    rollupOptions: {
+      output: {
+        format: "es",
+        entryFileNames: "main.js"
+      }
+    }
+  },
+  ssr: {
+    target: "node"
+  }
+})

package/vitest.config.ts

@@ -7,75 +7,79 @@
 // EFFECT: Effect<TestReport, never, TestEnvironment>
 // COMPLEXITY: O(n) test execution where n = |test_files|
 
-import { defineConfig } from "vitest/config";
-import tsconfigPaths from "vite-tsconfig-paths";
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import tsconfigPaths from "vite-tsconfig-paths"
+import { defineConfig } from "vitest/config"
 
-export default defineConfig({
-	plugins: [tsconfigPaths()], // Resolves @/* paths from tsconfig
-	test: {
-		// CHANGE: Native ESM support without experimental flags
-		// WHY: Vitest designed for ESM, no need for --experimental-vm-modules
-		// INVARIANT: Deterministic test execution without side effects
-		globals: false, // IMPORTANT: Use explicit imports for type safety
-		environment: "node",
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
 
-		// CHANGE: Match Jest's test file patterns
-		// INVARIANT: Same test discovery as Jest
-		include: ["tests/**/*.{test,spec}.ts"],
-		exclude: ["node_modules", "dist", "dist-test"],
+export default defineConfig({
+  plugins: [tsconfigPaths()], // Resolves @/* paths from tsconfig
+  test: {
+    // CHANGE: Native ESM support without experimental flags
+    // WHY: Vitest designed for ESM, no need for --experimental-vm-modules
+    // INVARIANT: Deterministic test execution without side effects
+    globals: false, // IMPORTANT: Use explicit imports for type safety
+    environment: "node",
 
-		// CHANGE: Coverage with 100% threshold for CORE (same as Jest)
-		// WHY: CORE must maintain mathematical guarantees via complete coverage
-		// INVARIANT: coverage_vitest ≥ coverage_jest ∧ ∀ f ∈ CORE: coverage(f) = 100%
-		coverage: {
-			provider: "v8", // Faster than babel (istanbul), native V8 coverage
-			reporter: ["text", "json", "html"],
-			include: ["src/**/*.ts"],
-			exclude: [
-				"src/**/*.test.ts",
-				"src/**/*.spec.ts",
-				"src/**/__tests__/**",
-				"scripts/**/*.ts",
-			],
-			// CHANGE: Maintain exact same thresholds as Jest
-			// WHY: Enforce 100% coverage for CORE, 10% minimum for SHELL
-			// INVARIANT: ∀ f ∈ src/core/**/*.ts: all_metrics(f) = 100%
-			// NOTE: Vitest v8 provider collects coverage for all matched files by default
-			thresholds: {
-				"src/core/**/*.ts": {
-					branches: 100,
-					functions: 100,
-					lines: 100,
-					statements: 100,
-				},
-				global: {
-					branches: 10,
-					functions: 10,
-					lines: 10,
-					statements: 10,
-				},
-			},
-		},
+    // CHANGE: Match Jest's test file patterns
+    // INVARIANT: Same test discovery as Jest
+    include: ["tests/**/*.{test,spec}.ts"],
+    exclude: ["node_modules", "dist", "dist-test"],
 
-		// CHANGE: Faster test execution via thread pooling
-		// WHY: Vitest uses worker threads by default (faster than Jest's processes)
-		// COMPLEXITY: O(n/k) where n = tests, k = worker_count
-		// NOTE: Vitest runs tests in parallel by default, no additional config needed
+    // CHANGE: Coverage with 100% threshold for CORE (same as Jest)
+    // WHY: CORE must maintain mathematical guarantees via complete coverage
+    // INVARIANT: coverage_vitest ≥ coverage_jest ∧ ∀ f ∈ CORE: coverage(f) = 100%
+    coverage: {
+      provider: "v8", // Faster than babel (istanbul), native V8 coverage
+      reporter: ["text", "json", "html"],
+      include: ["src/**/*.ts"],
+      exclude: [
+        "src/**/*.test.ts",
+        "src/**/*.spec.ts",
+        "src/**/__tests__/**",
+        "scripts/**/*.ts"
+      ],
+      // CHANGE: Maintain exact same thresholds as Jest
+      // WHY: Enforce 100% coverage for CORE, 10% minimum for SHELL
+      // INVARIANT: ∀ f ∈ src/core/**/*.ts: all_metrics(f) = 100%
+      // NOTE: Vitest v8 provider collects coverage for all matched files by default
+      thresholds: {
+        "src/core/**/*.ts": {
+          branches: 100,
+          functions: 100,
+          lines: 100,
+          statements: 100
+        },
+        global: {
+          branches: 10,
+          functions: 10,
+          lines: 10,
+          statements: 10
+        }
+      }
+    },
 
-		// CHANGE: Clear mocks between tests (Jest equivalence)
-		// WHY: Prevent test contamination, ensure test independence
-		// INVARIANT: ∀ test_i, test_j: independent(test_i, test_j) ⇒ no_shared_state
-		clearMocks: true,
-		mockReset: true,
-		restoreMocks: true,
+    // CHANGE: Faster test execution via thread pooling
+    // WHY: Vitest uses worker threads by default (faster than Jest's processes)
+    // COMPLEXITY: O(n/k) where n = tests, k = worker_count
+    // NOTE: Vitest runs tests in parallel by default, no additional config needed
 
-		// CHANGE: Disable globals to enforce explicit imports
-		// WHY: Type safety, explicit dependencies, functional purity
-		// NOTE: Tests must import { describe, it, expect } from "vitest"
-	},
-	resolve: {
-		alias: {
-			"@": "/src",
-		},
-	},
-});
+    // CHANGE: Clear mocks between tests (Jest equivalence)
+    // WHY: Prevent test contamination, ensure test independence
+    // INVARIANT: ∀ test_i, test_j: independent(test_i, test_j) ⇒ no_shared_state
+    clearMocks: true,
+    mockReset: true,
+    restoreMocks: true
+    // CHANGE: Disable globals to enforce explicit imports
+    // WHY: Type safety, explicit dependencies, functional purity
+    // NOTE: Tests must import { describe, it, expect } from "vitest"
+  },
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "src")
+    }
+  }
+})

package/README.md

@@ -1,42 +0,0 @@
-# Knowledge Sync CLI
-
-Command: `npx @prover-coder-ai/context-doc [flags]` (or `context-doc` when installed globally) — copies project dialogs into `.knowledge` for both Codex and Qwen.
-
-## Installation (global CLI)
-- Install: `npm install -g @prover-coder-ai/context-doc`
-- Registry page: https://www.npmjs.com/package/@prover-coder-ai/context-doc
-- Run globally: `context-doc [flags]`
-- Ad-hoc (no install): `npx @prover-coder-ai/context-doc [flags]`
-- Local (without global install): `npm run sync:knowledge` or `tsx src/shell/syncKnowledge.ts`
-
-## Usage examples
-- Default (auto-detect sources/destinations): `context-doc`
-- Custom Codex source/destination: `context-doc --source /tmp/project/.codex --dest /tmp/project/.knowledge/.codex`
-- Custom meta root (both Codex/Qwen resolution): `context-doc --meta-root /data/meta`
-- Override project URL: `context-doc --project-url https://github.com/your/repo`
-- Qwen source override: `context-doc --qwen-source /data/qwen/tmp/abcd1234`
-
-## Flags
-- `--source, -s <path>` — explicit path to `.codex` (Codex source).
-- `--dest, -d <path>` — Codex destination root (defaults to `.knowledge/.codex`).
-- `--project-url` / `--project-name <url>` — override repository URL (otherwise read from `package.json`).
-- `--meta-root <path>` — meta folder root; Codex lookup tries `<meta-root>/.codex`, Qwen lookup tries `<meta-root>/.qwen/tmp/<hash>`.
-- `--qwen-source <path>` — explicit path to Qwen source.
-
-## Codex lookup order (`.jsonl` filtered by project)
-1) `--source`
-2) env `CODEX_SOURCE_DIR`
-3) `--meta-root` (use if already `.codex` or append `/.codex`)
-4) project-local `.codex`
-5) home `~/.codex`
-
-Files: copies only `.jsonl` whose `git.repository_url` or `cwd` match this project into `.knowledge/.codex`, preserving structure.
-
-## Qwen lookup order (`.json` only, no project filter)
-1) `--qwen-source`
-2) env `QWEN_SOURCE_DIR`
-3) `<meta-root>/.qwen/tmp/<hash>`
-4) `<cwd>/.qwen/tmp/<hash>`
-5) `~/.qwen/tmp/<hash>`
-
-Files: copies only `.json` into `.knowledge/.qwen`, preserving structure (directories recreated).

package/dist/core/greeting.js

@@ -1,25 +0,0 @@
-import { Option } from "effect";
-const normalize = (value) => value.trim();
-const isNonEmpty = (value) => value.length > 0;
-/**
- * CHANGE: Introduce pure greeting synthesis for console entrypoint
- * WHY: Provide mathematically checkable construction of startup banner without side effects
- * QUOTE(ТЗ): "Каждая функция — это теорема."
- * REF: REQ-GREETING-CORE
- * SOURCE: AGENTS.md – функциональное ядро без побочных эффектов
- * FORMAT THEOREM: ∀p ∈ AppProfile: valid(p) → nonEmpty(buildGreeting(p).message)
- * PURITY: CORE
- * EFFECT: None (pure)
- * INVARIANT: output.message.length > 0 when Option is Some
- * COMPLEXITY: O(1)/O(1)
- */
-export const buildGreeting = (profile) => {
-    const trimmedName = normalize(profile.name);
-    const trimmedMission = normalize(profile.mission);
-    if (!isNonEmpty(trimmedName) || !isNonEmpty(trimmedMission)) {
-        return Option.none();
-    }
-    return Option.some({
-        message: `${trimmedName}: ${trimmedMission}`,
-    });
-};

package/dist/core/knowledge.js

@@ -1,54 +0,0 @@
-import path from "node:path";
-import { Option, pipe } from "effect";
-const isJsonRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const normalizeRepositoryUrl = (value) => pipe(value.trim(), (trimmed) => trimmed.replace(/^git\+/, ""), (withoutPrefix) => withoutPrefix.replace(/\.git$/, ""), (withoutGitSuffix) => withoutGitSuffix.replace(/^git@github\.com:/, "https://github.com/"), (withoutSsh) => withoutSsh.replace(/^ssh:\/\/git@github\.com\//, "https://github.com/"), (normalized) => normalized.toLowerCase());
-const normalizeCwd = (value) => path.resolve(value);
-const pickString = (record, key) => {
-    const candidate = record[key];
-    return typeof candidate === "string" ? Option.some(candidate) : Option.none();
-};
-const pickRecord = (record, key) => pipe(record[key], Option.fromNullable, Option.filter(isJsonRecord));
-const pickGitRepository = (record) => pipe(pickString(record, "repository_url"), Option.orElse(() => pickString(record, "repositoryUrl")));
-const extractRepository = (record) => pipe(pickRecord(record, "git"), Option.flatMap(pickGitRepository), Option.orElse(() => pipe(pickRecord(record, "payload"), Option.flatMap((payload) => pipe(pickRecord(payload, "git"), Option.flatMap(pickGitRepository))))));
-const extractCwd = (record) => pipe(pickString(record, "cwd"), Option.orElse(() => pipe(pickRecord(record, "payload"), Option.flatMap((payload) => pickString(payload, "cwd")))));
-const toMetadata = (value) => {
-    if (!isJsonRecord(value)) {
-        return { repositoryUrl: Option.none(), cwd: Option.none() };
-    }
-    return {
-        repositoryUrl: extractRepository(value),
-        cwd: extractCwd(value),
-    };
-};
-const normalizeLocator = (repositoryUrl, cwd) => ({
-    normalizedRepositoryUrl: normalizeRepositoryUrl(repositoryUrl),
-    normalizedCwd: normalizeCwd(cwd),
-});
-const safeParseJson = (line) => {
-    try {
-        return Option.some(JSON.parse(line));
-    }
-    catch {
-        return Option.none();
-    }
-};
-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 fallbackCwdOnly
-            ? normalized === locator.normalizedCwd
-            : locator.normalizedCwd.startsWith(normalized) ||
-                normalized.startsWith(locator.normalizedCwd);
-    });
-    return repoMatches || cwdMatches;
-};
-export const buildProjectLocator = (repositoryUrl, cwd) => normalizeLocator(repositoryUrl, cwd);
-export const linesMatchProject = (lines, locator) => lines.some((line) => {
-    const trimmed = line.trim();
-    if (trimmed.length === 0) {
-        return false;
-    }
-    return pipe(safeParseJson(trimmed), Option.map(toMetadata), Option.exists((metadata) => metadataMatches(metadata, locator)));
-});

package/dist/main.js

@@ -1,27 +0,0 @@
-import { Console, Effect, Option, pipe } from "effect";
-import { match } from "ts-pattern";
-import { buildGreeting } from "./core/greeting.js";
-const appProfile = {
-    name: "Context Console",
-    mission: "Functional core ready for verifiable effects",
-};
-const toStartupError = (reason) => ({
-    _tag: "StartupError",
-    reason,
-});
-/**
- * CHANGE: Compose shell-level startup program around pure greeting builder
- * WHY: Isolate side effects (console IO) while delegating computation to functional core
- * QUOTE(ТЗ): "FUNCTIONAL CORE, IMPERATIVE SHELL"
- * REF: REQ-SHELL-STARTUP
- * SOURCE: AGENTS.md — эффекты только в SHELL
- * FORMAT THEOREM: ∀profile: valid(profile) → logs(buildGreeting(profile))
- * PURITY: SHELL
- * EFFECT: Effect<void, StartupError, Console>
- * INVARIANT: Console side-effects occur once and only after successful greeting synthesis
- * COMPLEXITY: O(1)/O(1)
- */
-const program = pipe(Effect.succeed(buildGreeting(appProfile)), Effect.filterOrFail(Option.isSome, () => toStartupError("Profile must not be empty")), Effect.map((option) => option.value), Effect.flatMap((greeting) => Console.log(greeting.message)), Effect.catchAll((error) => match(error)
-    .with({ _tag: "StartupError" }, (startupError) => Console.error(`StartupError: ${startupError.reason}`))
-    .exhaustive()));
-Effect.runSync(program);

package/dist/shell/claudeSync.js

@@ -1,23 +0,0 @@
-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/cli.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-import { Effect } from "effect";
-import { buildSyncProgram, parseArgs } from "./syncKnowledge.js";
-const program = buildSyncProgram(parseArgs());
-Effect.runSync(program);