@prover-coder-ai/context-doc 1.0.17 → 1.0.19

package/README.md

@@ -0,0 +1,18 @@
+# @prover-coder-ai/context-doc
+
+Syncs AI assistant conversation history (Claude, Codex, Qwen) to your project's `.knowledge` folder.
+
+## Usage
+
+```bash
+npx @prover-coder-ai/context-doc
+```
+
+Example:
+
+```
+user@arch ~/effect-template (main)> npx @prover-coder-ai/context-doc
+Claude: source not found; skipped syncing (Claude project directory is missing)
+Codex: copied 9 files from /home/user/.codex to /home/user/effect-template/.knowledge/.codex
+Qwen: copied 1 files from /home/user/.qwen/tmp/040644799b0a7c05ac8df9cf26da0eab978287161b20ee2addc8105393cf98dd to /home/user/effect-template/.knowledge/.qwen
+```

package/dist/main.js

@@ -0,0 +1,553 @@
+import { NodeContext, NodeRuntime } from "@effect/platform-node";
+import { Context, Layer, pipe, Effect, Option, Match, Console } from "effect";
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Path from "@effect/platform/Path";
+import * as Schema from "@effect/schema/Schema";
+class CryptoService extends Context.Tag("CryptoService")() {
+}
+const cryptoError = (reason) => ({
+  _tag: "CryptoError",
+  reason
+});
+const toHex = (buffer) => [...new Uint8Array(buffer)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+const digestSha256 = (value) => pipe(
+  Effect.tryPromise({
+    try: () => {
+      const crypto = globalThis.crypto;
+      const bytes = new TextEncoder().encode(value);
+      return crypto.subtle.digest("SHA-256", bytes);
+    },
+    catch: (error) => cryptoError(error instanceof Error ? error.message : "Crypto digest failed")
+  }),
+  Effect.map((buffer) => toHex(buffer))
+);
+const CryptoServiceLive = Layer.succeed(CryptoService, {
+  sha256: (value) => digestSha256(value)
+});
+const syncError = (pathValue, reason) => ({
+  _tag: "SyncError",
+  path: pathValue,
+  reason
+});
+class FileSystemService extends Context.Tag("FileSystemService")() {
+}
+const forEach$2 = Effect.forEach;
+const resolveEntryPath = (path, root, entry) => path.isAbsolute(entry) ? entry : path.join(root, entry);
+const entryKindFromInfo = (info) => {
+  if (info.type === "Directory") {
+    return "directory";
+  }
+  if (info.type === "File") {
+    return "file";
+  }
+  return "other";
+};
+const toDirectoryEntry = (path, entryPath, info) => ({
+  name: path.basename(entryPath),
+  path: entryPath,
+  kind: entryKindFromInfo(info)
+});
+const missingEntry = (path, entryPath) => ({
+  name: path.basename(entryPath),
+  path: entryPath,
+  kind: "other"
+});
+const isNotFoundError = (error) => error._tag === "SystemError" && error.reason === "NotFound";
+const readEntry = (fs, path, entryPath) => pipe(
+  fs.stat(entryPath),
+  Effect.map((info) => toDirectoryEntry(path, entryPath, info)),
+  Effect.catchIf(isNotFoundError, () => Effect.succeed(missingEntry(path, entryPath))),
+  Effect.mapError(() => syncError(entryPath, "Cannot read directory entry"))
+);
+const resolveEntry = (fs, path, root, entry) => {
+  const entryPath = resolveEntryPath(path, root, entry);
+  return readEntry(fs, path, entryPath);
+};
+const FileSystemLive = Layer.effect(
+  FileSystemService,
+  Effect.gen(function* (_) {
+    const fs = yield* _(FileSystem.FileSystem);
+    const path = yield* _(Path.Path);
+    const readFileString = (pathValue) => pipe(
+      fs.readFileString(pathValue, "utf8"),
+      Effect.mapError(() => syncError(pathValue, "Cannot read file"))
+    );
+    const readDirectory = (pathValue) => pipe(
+      fs.readDirectory(pathValue),
+      Effect.mapError(() => syncError(pathValue, "Cannot read directory")),
+      Effect.flatMap((entries) => forEach$2(entries, (entry) => resolveEntry(fs, path, pathValue, entry)))
+    );
+    const makeDirectory = (pathValue) => pipe(
+      fs.makeDirectory(pathValue, { recursive: true }),
+      Effect.mapError(() => syncError(pathValue, "Cannot create destination directory structure"))
+    );
+    const copyFile = (sourcePath, destinationPath) => pipe(
+      fs.copyFile(sourcePath, destinationPath),
+      Effect.mapError(() => syncError(sourcePath, "Cannot copy file into destination"))
+    );
+    const exists = (pathValue) => pipe(
+      fs.exists(pathValue),
+      Effect.mapError(() => syncError(pathValue, "Cannot check path existence"))
+    );
+    return {
+      readFileString,
+      readDirectory,
+      makeDirectory,
+      copyFile,
+      exists
+    };
+  })
+);
+class RuntimeEnv extends Context.Tag("RuntimeEnv")() {
+}
+const readProcess = () => typeof process === "undefined" ? void 0 : process;
+const readEnv = () => readProcess()?.env ?? {};
+const resolveHomeDir = (env, cwdFallback) => {
+  const direct = env["HOME"] ?? env["USERPROFILE"];
+  if (direct !== void 0) {
+    return direct;
+  }
+  const drive = env["HOMEDRIVE"];
+  const path = env["HOMEPATH"];
+  if (drive !== void 0 && path !== void 0) {
+    return `${drive}${path}`;
+  }
+  return cwdFallback;
+};
+const RuntimeEnvLive = Layer.succeed(RuntimeEnv, {
+  argv: Effect.sync(() => {
+    const proc = readProcess();
+    return proc === void 0 ? [] : [...proc.argv];
+  }),
+  cwd: Effect.sync(() => readProcess()?.cwd() ?? "."),
+  homedir: Effect.sync(() => {
+    const proc = readProcess();
+    const cwdFallback = proc?.cwd() ?? ".";
+    return resolveHomeDir(readEnv(), cwdFallback);
+  }),
+  envVar: (key) => Effect.sync(() => Option.fromNullable(readEnv()[key]))
+});
+const flagMap = /* @__PURE__ */ new Map([
+  ["--project-root", "projectRoot"],
+  ["-r", "projectRoot"],
+  ["--source", "sourceDir"],
+  ["-s", "sourceDir"],
+  ["--dest", "destinationDir"],
+  ["-d", "destinationDir"],
+  ["--project-url", "repositoryUrlOverride"],
+  ["--project-name", "repositoryUrlOverride"],
+  ["--meta-root", "metaRoot"],
+  ["--qwen-source", "qwenSourceDir"],
+  ["--claude-projects", "claudeProjectsRoot"]
+]);
+const parseArgs = (args, cwd) => {
+  let result = { cwd };
+  let index = 0;
+  while (index < args.length) {
+    const arg = args[index];
+    if (arg === void 0) {
+      index += 1;
+      continue;
+    }
+    const key = flagMap.get(arg);
+    if (key === void 0) {
+      index += 1;
+      continue;
+    }
+    const value = args[index + 1];
+    if (value !== void 0) {
+      result = { ...result, [key]: value };
+      index += 2;
+      continue;
+    }
+    index += 1;
+  }
+  return result;
+};
+const readSyncOptions = Effect.gen(function* (_) {
+  const env = yield* _(RuntimeEnv);
+  const argv = yield* _(env.argv);
+  const cwd = yield* _(env.cwd);
+  return parseArgs(argv.slice(2), cwd);
+});
+const forEach$1 = Effect.forEach;
+const ensureDirectory = (directory) => Effect.gen(function* (_) {
+  const fs = yield* _(FileSystemService);
+  yield* _(fs.makeDirectory(directory));
+});
+const collectFiles = (root, isRelevant) => Effect.gen(function* (_) {
+  const fs = yield* _(FileSystemService);
+  const entries = yield* _(fs.readDirectory(root));
+  const chunks = yield* _(
+    forEach$1(entries, (entry) => Match.value(entry.kind).pipe(
+      Match.when("directory", () => collectFiles(entry.path, isRelevant)),
+      Match.when("file", () => isRelevant(entry) ? Effect.succeed([entry.path]) : Effect.succeed([])),
+      Match.when("other", () => Effect.succeed([])),
+      Match.exhaustive
+    ))
+  );
+  return chunks.flat();
+});
+const copyFilePreservingRelativePath = (sourceRoot, destinationRoot, filePath) => Effect.gen(function* (_) {
+  const fs = yield* _(FileSystemService);
+  const path = yield* _(Path.Path);
+  const relative = path.relative(sourceRoot, filePath);
+  const targetPath = path.join(destinationRoot, relative);
+  yield* _(fs.makeDirectory(path.dirname(targetPath)));
+  yield* _(fs.copyFile(filePath, targetPath));
+});
+const findFirstMatching = (candidates, matches) => {
+  const loop = (remaining) => Effect.gen(function* (_) {
+    const [candidate, ...rest] = remaining;
+    if (candidate === void 0) {
+      return;
+    }
+    const matched = yield* _(matches(candidate));
+    if (!matched) {
+      return yield* _(loop(rest));
+    }
+    return candidate;
+  });
+  return loop(candidates);
+};
+const ensureDestination = ensureDirectory;
+const resolveProjectRoot = (path, options) => path.resolve(options.projectRoot ?? options.cwd);
+const copyFilteredFiles = (sourceRoot, destinationRoot, isRelevant, errorReason) => pipe(
+  Effect.gen(function* (_) {
+    const files = yield* _(collectFiles(sourceRoot, (entry) => isRelevant(entry, entry.path)));
+    yield* _(
+      forEach$1(files, (filePath) => copyFilePreservingRelativePath(sourceRoot, destinationRoot, filePath))
+    );
+    return files.length;
+  }),
+  Effect.mapError(() => syncError(sourceRoot, errorReason))
+);
+const createFilteredSource = (params) => ({
+  name: params.name,
+  destSubdir: params.destSubdir,
+  resolveSource: params.resolveSource,
+  copy: (sourceDir, destinationDir) => copyFilteredFiles(sourceDir, destinationDir, params.filter, params.errorReason)
+});
+const runSyncSource = (source, options) => pipe(
+  Effect.gen(function* (_) {
+    const path = yield* _(Path.Path);
+    const resolvedSource = yield* _(source.resolveSource(options));
+    const destination = path.join(
+      resolveProjectRoot(path, options),
+      ".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.matchEffect({
+    onFailure: (error) => Console.log(
+      `${source.name}: source not found; skipped syncing (${error.reason})`
+    ),
+    onSuccess: () => Effect.void
+  })
+);
+const slugFromCwd = (cwd) => `-${cwd.replace(/^\/+/, "").replaceAll("\\", "-").replaceAll("/", "-")}`;
+const resolveClaudeProjectDir = (options) => Effect.gen(function* (_) {
+  const env = yield* _(RuntimeEnv);
+  const homeDir = yield* _(env.homedir);
+  const path = yield* _(Path.Path);
+  const base = options.claudeProjectsRoot ?? path.join(homeDir, ".claude", "projects");
+  const candidate = path.join(base, slugFromCwd(resolveProjectRoot(path, options)));
+  const fs = yield* _(FileSystemService);
+  const exists = yield* _(fs.exists(candidate));
+  if (!exists) {
+    return yield* _(
+      Effect.fail(syncError(".claude", "Claude project directory is missing"))
+    );
+  }
+  return candidate;
+});
+const claudeSource = createFilteredSource({
+  name: "Claude",
+  destSubdir: ".claude",
+  resolveSource: resolveClaudeProjectDir,
+  filter: (entry, fullPath) => entry.kind === "file" && fullPath.endsWith(".jsonl"),
+  errorReason: "Cannot traverse Claude project"
+});
+const syncClaude = (options) => runSyncSource(claudeSource, options);
+const isJsonRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const pickString = (record, key) => {
+  const candidate = record[key];
+  return Option.fromNullable(typeof candidate === "string" ? candidate : null);
+};
+const pickRecord = (record, key) => pipe(
+  record[key],
+  Option.fromNullable,
+  Option.filter((value) => isJsonRecord(value))
+);
+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 { cwd: Option.none() };
+  }
+  return {
+    cwd: extractCwd(value)
+  };
+};
+const cwdMatches = (metadata, locator) => Option.exists(metadata.cwd, (cwdValue) => locator.isWithinRoot(cwdValue));
+const metadataMatches = (metadata, locator) => cwdMatches(metadata, locator);
+const buildProjectLocator = (normalizedCwd, isWithinRoot) => ({
+  normalizedCwd,
+  isWithinRoot
+});
+const valueMatchesProject = (value, locator) => metadataMatches(toMetadata(value), locator);
+const some = Option.some;
+const forEach = Effect.forEach;
+const JsonValueSchema = Schema.suspend(
+  () => Schema.Union(
+    Schema.String,
+    Schema.Number,
+    Schema.Boolean,
+    Schema.Null,
+    Schema.Array(JsonValueSchema),
+    Schema.Record({ key: Schema.String, value: JsonValueSchema })
+  )
+);
+const parseJsonLine = (line) => pipe(
+  Schema.decode(Schema.parseJson(JsonValueSchema))(line),
+  Effect.match({
+    onFailure: () => Option.none(),
+    onSuccess: (value) => some(value)
+  })
+);
+const resolveEnvValue$1 = (envValue) => Option.getOrUndefined(envValue);
+const buildLocator = (path, projectRoot) => {
+  const normalizedRoot = path.resolve(projectRoot);
+  const isWithinRoot = (candidate) => {
+    const normalizedCandidate = path.resolve(candidate);
+    const relative = path.relative(normalizedRoot, normalizedCandidate);
+    return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+  };
+  return buildProjectLocator(normalizedRoot, isWithinRoot);
+};
+const containsJsonl = (root) => Effect.gen(function* (_) {
+  const fs = yield* _(FileSystemService);
+  const entries = yield* _(fs.readDirectory(root));
+  for (const entry of entries) {
+    if (entry.kind === "file" && entry.path.endsWith(".jsonl")) {
+      return true;
+    }
+    if (entry.kind === "directory") {
+      const found = yield* _(containsJsonl(entry.path));
+      if (found) {
+        return true;
+      }
+    }
+  }
+  return false;
+});
+const hasJsonlInCandidate = (candidate) => Effect.gen(function* (_) {
+  const fs = yield* _(FileSystemService);
+  const exists = yield* _(fs.exists(candidate));
+  if (!exists) {
+    return false;
+  }
+  return yield* _(containsJsonl(candidate));
+});
+const findFirstExistingWithJsonl = (candidates) => findFirstMatching(candidates, hasJsonlInCandidate);
+const resolveSourceDir = (options) => Effect.gen(function* (_) {
+  const env = yield* _(RuntimeEnv);
+  const path = yield* _(Path.Path);
+  const envSource = resolveEnvValue$1(yield* _(env.envVar("CODEX_SOURCE_DIR")));
+  const homeDir = yield* _(env.homedir);
+  const projectRoot = resolveProjectRoot(path, options);
+  let metaCandidate;
+  if (options.metaRoot !== void 0) {
+    metaCandidate = options.metaRoot.endsWith(".codex") ? options.metaRoot : path.join(options.metaRoot, ".codex");
+  }
+  const localSource = path.join(projectRoot, ".codex");
+  const localKnowledge = path.join(projectRoot, ".knowledge", ".codex");
+  const homeSource = path.join(homeDir, ".codex");
+  const homeKnowledge = path.join(homeDir, ".knowledge", ".codex");
+  const candidates = [
+    options.sourceDir,
+    envSource,
+    metaCandidate,
+    localSource,
+    homeSource,
+    localKnowledge,
+    homeKnowledge
+  ].filter((candidate) => candidate !== void 0);
+  const existing = yield* _(findFirstExistingWithJsonl(candidates));
+  if (existing === void 0) {
+    return yield* _(
+      Effect.fail(
+        syncError(
+          ".codex",
+          `No .jsonl files found in .codex candidates; checked: ${candidates.join(", ")}`
+        )
+      )
+    );
+  }
+  return existing;
+});
+const resolveLocator = (options) => Effect.gen(function* (_) {
+  const path = yield* _(Path.Path);
+  const projectRoot = resolveProjectRoot(path, options);
+  return buildLocator(path, projectRoot);
+});
+const lineMatchesProject = (line, locator) => pipe(
+  parseJsonLine(line),
+  Effect.map((parsed) => Option.exists(parsed, (value) => valueMatchesProject(value, locator)))
+);
+const fileMatchesProject = (filePath, locator) => Effect.gen(function* (_) {
+  const fs = yield* _(FileSystemService);
+  const content = yield* _(fs.readFileString(filePath));
+  const lines = content.split("\n");
+  const matches = yield* _(
+    forEach(lines, (line) => {
+      const trimmed = line.trim();
+      return trimmed.length === 0 ? Effect.succeed(false) : lineMatchesProject(trimmed, locator);
+    })
+  );
+  return matches.some(Boolean);
+});
+const selectRelevantFiles = (files, locator) => pipe(
+  forEach(files, (filePath) => pipe(
+    fileMatchesProject(filePath, locator),
+    Effect.map((matches) => ({ filePath, matches }))
+  )),
+  Effect.map(
+    (results) => results.filter((result) => result.matches).map((result) => result.filePath)
+  )
+);
+const copyCodexFiles = (sourceDir, destinationDir, locator) => Effect.gen(function* (_) {
+  yield* _(ensureDestination(destinationDir));
+  const allJsonlFiles = yield* _(
+    collectFiles(sourceDir, (entry) => entry.kind === "file" && entry.path.endsWith(".jsonl"))
+  );
+  const relevantFiles = yield* _(selectRelevantFiles(allJsonlFiles, locator));
+  yield* _(
+    forEach(relevantFiles, (filePath) => copyFilePreservingRelativePath(sourceDir, destinationDir, filePath))
+  );
+  yield* _(
+    Console.log(
+      `Codex: copied ${relevantFiles.length} files from ${sourceDir} to ${destinationDir}`
+    )
+  );
+});
+const syncCodex = (options) => Effect.gen(function* (_) {
+  const locator = yield* _(resolveLocator(options));
+  const sourceDir = yield* _(resolveSourceDir(options));
+  const path = yield* _(Path.Path);
+  const destinationDir = options.destinationDir ?? path.join(resolveProjectRoot(path, options), ".knowledge", ".codex");
+  if (path.resolve(sourceDir) === path.resolve(destinationDir)) {
+    yield* _(
+      Console.log(
+        "Codex source equals destination; skipping copy to avoid duplicates"
+      )
+    );
+    return;
+  }
+  yield* _(copyCodexFiles(sourceDir, destinationDir, locator));
+}).pipe(
+  Effect.matchEffect({
+    onFailure: (error) => Console.log(
+      `Codex source not found; skipped syncing Codex dialog files (${error.reason})`
+    ),
+    onSuccess: () => Effect.void
+  })
+);
+const resolveEnvValue = (envValue) => Option.getOrUndefined(envValue);
+const findFirstExisting = (candidates) => findFirstMatching(candidates, (candidate) => Effect.gen(function* (_) {
+  const fs = yield* _(FileSystemService);
+  return yield* _(fs.exists(candidate));
+}));
+const resolveQwenSourceDir = (options) => Effect.gen(function* (_) {
+  const env = yield* _(RuntimeEnv);
+  const crypto = yield* _(CryptoService);
+  const path = yield* _(Path.Path);
+  const projectRoot = resolveProjectRoot(path, options);
+  const hash = yield* _(
+    pipe(
+      crypto.sha256(projectRoot),
+      Effect.mapError((error) => syncError(".qwen", error.reason))
+    )
+  );
+  const envSource = resolveEnvValue(yield* _(env.envVar("QWEN_SOURCE_DIR")));
+  const homeDir = yield* _(env.homedir);
+  let baseFromMeta;
+  if (options.metaRoot !== void 0) {
+    baseFromMeta = options.metaRoot.endsWith(".qwen") ? options.metaRoot : path.join(options.metaRoot, ".qwen");
+  }
+  const metaKnowledge = options.metaRoot === void 0 ? void 0 : path.join(options.metaRoot, ".knowledge", ".qwen");
+  const homeBase = path.join(homeDir, ".qwen");
+  const homeKnowledge = path.join(homeDir, ".knowledge", ".qwen");
+  const candidates = [
+    options.qwenSourceDir,
+    envSource,
+    baseFromMeta ? path.join(baseFromMeta, "tmp", hash) : void 0,
+    path.join(projectRoot, ".qwen", "tmp", hash),
+    path.join(projectRoot, ".knowledge", ".qwen", "tmp", hash),
+    metaKnowledge ? path.join(metaKnowledge, "tmp", hash) : void 0,
+    path.join(homeBase, "tmp", hash),
+    path.join(homeKnowledge, "tmp", hash)
+  ].filter((candidate) => candidate !== void 0);
+  const found = yield* _(findFirstExisting(candidates));
+  if (found === void 0) {
+    return yield* _(
+      Effect.fail(
+        syncError(
+          ".qwen",
+          `Qwen source directory is missing for hash ${hash}`
+        )
+      )
+    );
+  }
+  return found;
+});
+const qwenSource = createFilteredSource({
+  name: "Qwen",
+  destSubdir: ".qwen",
+  resolveSource: resolveQwenSourceDir,
+  filter: (entry, fullPath) => entry.kind === "file" && fullPath.endsWith(".json"),
+  errorReason: "Cannot traverse Qwen directory"
+});
+const syncQwen = (options) => runSyncSource(qwenSource, options);
+const buildSyncProgram = (options) => Effect.gen(function* (_) {
+  yield* _(syncClaude(options));
+  yield* _(syncCodex(options));
+  yield* _(syncQwen(options));
+});
+const program = pipe(
+  readSyncOptions,
+  Effect.flatMap((options) => buildSyncProgram(options))
+);
+const main = pipe(
+  program,
+  Effect.provide(
+    Layer.provideMerge(
+      Layer.mergeAll(RuntimeEnvLive, FileSystemLive, CryptoServiceLive),
+      NodeContext.layer
+    )
+  )
+);
+NodeRuntime.runMain(main);
+//# sourceMappingURL=main.js.map