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

package/src/shell/sync/sources/qwen.ts

@@ -1,97 +0,0 @@
-import * as Path from "@effect/platform/Path"
-import { Effect, Option, pipe } from "effect"
-
-import { CryptoService } from "../../services/crypto.js"
-import { FileSystemService } from "../../services/file-system.js"
-import { RuntimeEnv } from "../../services/runtime-env.js"
-import { createFilteredSource, findFirstMatching, resolveProjectRoot, runSyncSource } from "../shared.js"
-import { type SyncError, syncError, type SyncOptions, type SyncSource } from "../types.js"
-
-type QwenEnv = RuntimeEnv | CryptoService | FileSystemService | Path.Path
-
-const resolveEnvValue = (envValue: Option.Option<string>): string | undefined => Option.getOrUndefined(envValue)
-
-const findFirstExisting = (
-  candidates: ReadonlyArray<string>
-): Effect.Effect<string | undefined, SyncError, FileSystemService> =>
-  findFirstMatching(candidates, (candidate) =>
-    Effect.gen(function*(_) {
-      const fs = yield* _(FileSystemService)
-      return yield* _(fs.exists(candidate))
-    }))
-
-const resolveQwenSourceDir = (
-  options: SyncOptions
-): Effect.Effect<string, SyncError, QwenEnv> =>
-  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: string | undefined
-    if (options.metaRoot !== undefined) {
-      baseFromMeta = options.metaRoot.endsWith(".qwen")
-        ? options.metaRoot
-        : path.join(options.metaRoot, ".qwen")
-    }
-    const metaKnowledge = options.metaRoot === undefined
-      ? undefined
-      : 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) : undefined,
-      path.join(projectRoot, ".qwen", "tmp", hash),
-      path.join(projectRoot, ".knowledge", ".qwen", "tmp", hash),
-      metaKnowledge ? path.join(metaKnowledge, "tmp", hash) : undefined,
-      path.join(homeBase, "tmp", hash),
-      path.join(homeKnowledge, "tmp", hash)
-    ].filter((candidate): candidate is string => candidate !== undefined)
-
-    const found = yield* _(findFirstExisting(candidates))
-    if (found === undefined) {
-      return yield* _(
-        Effect.fail(
-          syncError(
-            ".qwen",
-            `Qwen source directory is missing for hash ${hash}`
-          )
-        )
-      )
-    }
-
-    return found
-  })
-
-const qwenSource: SyncSource<QwenEnv> = createFilteredSource({
-  name: "Qwen",
-  destSubdir: ".qwen",
-  resolveSource: resolveQwenSourceDir,
-  filter: (entry, fullPath) => entry.kind === "file" && fullPath.endsWith(".json"),
-  errorReason: "Cannot traverse Qwen directory"
-})
-
-// CHANGE: sync Qwen dialog files through shared sync runner
-// WHY: keep source-specific resolution isolated and reuse copy/traversal logic
-// QUOTE(TZ): "SHELL: Все эффекты (IO, сеть, БД, env/process) изолированы"
-// REF: user-2026-01-19-sync-rewrite
-// SOURCE: n/a
-// FORMAT THEOREM: forall f: json(f) -> copied(f)
-// PURITY: SHELL
-// EFFECT: Effect<void, never, FileSystemService | RuntimeEnv | CryptoService | Path>
-// INVARIANT: only .json files are copied
-// COMPLEXITY: O(n)/O(n)
-export const syncQwen = (
-  options: SyncOptions
-): Effect.Effect<void, never, QwenEnv> => runSyncSource(qwenSource, options)

package/src/shell/sync/types.ts

@@ -1,47 +0,0 @@
-import type * as Fx from "effect"
-
-export interface SyncError {
-  readonly _tag: "SyncError"
-  readonly path: string
-  readonly reason: string
-}
-
-export interface SyncOptions {
-  readonly cwd: string
-  readonly projectRoot?: string
-  readonly sourceDir?: string
-  readonly destinationDir?: string
-  readonly repositoryUrlOverride?: string
-  readonly metaRoot?: string
-  readonly qwenSourceDir?: string
-  readonly claudeProjectsRoot?: string
-}
-
-export type SyncEffect<A, R = never> = Fx.Effect.Effect<A, SyncError, R>
-
-export interface SyncSource<R> {
-  readonly name: string
-  readonly destSubdir: ".codex" | ".qwen" | ".claude"
-  readonly resolveSource: (options: SyncOptions) => SyncEffect<string, R>
-  readonly copy: (
-    sourceDir: string,
-    destinationDir: string,
-    options: SyncOptions
-  ) => SyncEffect<number, R>
-}
-
-// CHANGE: centralize sync-specific types to keep shell modules consistent
-// WHY: shared types and error model simplify composition and testing
-// QUOTE(TZ): "Ошибки: типизированы в сигнатурах функций"
-// REF: user-2026-01-19-sync-rewrite
-// SOURCE: n/a
-// FORMAT THEOREM: forall e: SyncError -> typed(e)
-// PURITY: SHELL
-// EFFECT: n/a
-// INVARIANT: SyncError contains path and reason for logging
-// COMPLEXITY: O(1)/O(1)
-export const syncError = (pathValue: string, reason: string): SyncError => ({
-  _tag: "SyncError",
-  path: pathValue,
-  reason
-})

package/tests/core/knowledge.test.ts

@@ -1,95 +0,0 @@
-import * as Path from "@effect/platform/Path"
-import { describe, expect, it } from "@effect/vitest"
-import { Effect } from "effect"
-import fc from "fast-check"
-
-import { buildProjectLocator, type JsonValue, valueMatchesProject } from "../../src/core/knowledge.js"
-
-const buildLocator = (root: string) =>
-  buildProjectLocator(
-    root,
-    (candidate) => candidate === root || candidate.startsWith(`${root}/`)
-  )
-
-describe("valueMatchesProject", () => {
-  const safeChar: fc.Arbitrary<string> = fc.constantFrom(
-    "a",
-    "b",
-    "c",
-    "d",
-    "e",
-    "f",
-    "0",
-    "1",
-    "2",
-    "3"
-  )
-  const segment: fc.Arbitrary<string> = fc.string({
-    minLength: 1,
-    maxLength: 8,
-    unit: safeChar
-  })
-  const nonRecordValue: fc.Arbitrary<JsonValue> = fc.oneof(
-    fc.string(),
-    fc.integer(),
-    fc.boolean(),
-    fc.constant(null),
-    fc.array(fc.string(), { maxLength: 5 }),
-    fc.array(fc.integer(), { maxLength: 5 }),
-    fc.array(fc.boolean(), { maxLength: 5 }),
-    fc.array(fc.constant(null), { maxLength: 5 })
-  )
-
-  const projectRoot = Effect.gen(function*(_) {
-    const path = yield* _(Path.Path)
-    const testFile = yield* _(path.fromFileUrl(new URL(import.meta.url)))
-    return path.resolve(path.dirname(testFile), "../../../..")
-  })
-
-  it.effect("matches by cwd inside project root", () =>
-    Effect.gen(function*(_) {
-      const root = yield* _(projectRoot)
-      const locator = buildLocator(root)
-      const insidePath: fc.Arbitrary<string> = fc
-        .array(segment, { minLength: 0, maxLength: 4 })
-        .map((segments) => segments.length === 0 ? root : `${root}/${segments.join("/")}`)
-      fc.assert(
-        fc.property(insidePath, (cwd: string) => {
-          const value: JsonValue = { cwd }
-          expect(valueMatchesProject(value, locator)).toBe(true)
-        })
-      )
-    }).pipe(Effect.provide(Path.layer)))
-
-  it.effect("rejects unrelated records", () =>
-    Effect.gen(function*(_) {
-      const root = yield* _(projectRoot)
-      const path = yield* _(Path.Path)
-      const locator = buildLocator(root)
-      const outsideBase = path.join(path.dirname(root), "outside")
-      const outsidePath: fc.Arbitrary<string> = fc
-        .array(segment, { minLength: 0, maxLength: 4 })
-        .map((segments) =>
-          segments.length === 0
-            ? outsideBase
-            : `${outsideBase}/${segments.join("/")}`
-        )
-      fc.assert(
-        fc.property(outsidePath, (cwd: string) => {
-          const value: JsonValue = { cwd }
-          expect(valueMatchesProject(value, locator)).toBe(false)
-        })
-      )
-    }).pipe(Effect.provide(Path.layer)))
-
-  it.effect("rejects non-record values", () =>
-    Effect.gen(function*(_) {
-      const root = yield* _(projectRoot)
-      const locator = buildLocator(root)
-      fc.assert(
-        fc.property(nonRecordValue, (value: JsonValue) => {
-          expect(valueMatchesProject(value, locator)).toBe(false)
-        })
-      )
-    }).pipe(Effect.provide(Path.layer)))
-})

package/tests/shell/cli-pack.test.ts

@@ -1,176 +0,0 @@
-import { NodeContext } from "@effect/platform-node"
-import * as Command from "@effect/platform/Command"
-import * as Path from "@effect/platform/Path"
-import { describe, expect, it } from "@effect/vitest"
-import { Effect, Layer, pipe } from "effect"
-
-import { buildTestPaths, makeTempDir, withFsPath, writeFile } from "../support/fs-helpers.js"
-
-const testPaths = buildTestPaths(
-  new URL(import.meta.url),
-  "context-doc-cli-tests",
-  "context-doc-pack-tests"
-)
-
-const runCommand = (command: Command.Command) =>
-  pipe(
-    Command.exitCode(command),
-    Effect.flatMap((exitCode) =>
-      Number(exitCode) === 0
-        ? Effect.void
-        : Effect.fail(new Error(`Command failed with exit code ${exitCode}`))
-    )
-  )
-
-const runCommandOutput = (command: Command.Command) => Command.string(command)
-
-const packCli = Effect.gen(function*(_) {
-  const { packBase, projectRoot } = yield* _(testPaths)
-  const path = yield* _(Path.Path)
-  const packDir = yield* _(
-    makeTempDir(
-      packBase ?? path.join(projectRoot, ".tmp", "context-doc-pack-tests"),
-      "pack-"
-    )
-  )
-
-  const build = pipe(
-    Command.make("pnpm", "--filter", "@prover-coder-ai/context-doc", "build"),
-    Command.workingDirectory(projectRoot)
-  )
-  yield* _(runCommand(build))
-
-  const appDir = path.join(projectRoot, "packages", "app")
-  const pack = pipe(
-    Command.make("npm", "pack", "--silent", "--pack-destination", packDir),
-    Command.workingDirectory(appDir)
-  )
-  const tarballName = (yield* _(runCommandOutput(pack))).trim()
-  const tarballPath = path.join(packDir, tarballName)
-  const tarballSpec = `file:${tarballPath}`
-
-  const tarballExists = yield* _(
-    withFsPath((fs) => fs.exists(tarballPath))
-  )
-  if (!tarballExists) {
-    return yield* _(Effect.fail(new Error("Packed tarball was not created")))
-  }
-
-  return { projectRoot, tarballSpec }
-})
-
-const prepareProject = Effect.gen(function*(_) {
-  const { tempBase } = yield* _(testPaths)
-  const path = yield* _(Path.Path)
-  const root = yield* _(
-    makeTempDir(tempBase, "project-")
-  )
-  const codexSource = path.join(root, "codex-src")
-  const destDir = path.join(root, ".knowledge", ".codex")
-  const qwenSource = path.join(root, "qwen-src")
-
-  yield* _(
-    writeFile(
-      path.join(codexSource, "sessions/2025/11/cli.jsonl"),
-      JSON.stringify({ cwd: root, message: "ok" })
-    )
-  )
-  yield* _(
-    writeFile(
-      path.join(qwenSource, "session-1.json"),
-      JSON.stringify({ sessionId: "s1" })
-    )
-  )
-
-  return { root, codexSource, destDir, qwenSource }
-})
-
-type CliRunner = "npx" | "pnpm-dlx"
-
-interface CliRunInput {
-  readonly runner: CliRunner
-  readonly tarballSpec: string
-  readonly root: string
-  readonly codexSource: string
-  readonly destDir: string
-  readonly qwenSource: string
-}
-
-const runCliWithRunner = ({
-  codexSource,
-  destDir,
-  qwenSource,
-  root,
-  runner,
-  tarballSpec
-}: CliRunInput) =>
-  Effect.gen(function*(_) {
-    const { projectRoot } = yield* _(testPaths)
-    const args = [
-      "--project-root",
-      root,
-      "--source",
-      codexSource,
-      "--dest",
-      destDir,
-      "--qwen-source",
-      qwenSource
-    ]
-    const command = pipe(
-      runner === "npx"
-        ? Command.make("npx", "-y", tarballSpec, ...args)
-        : Command.make("pnpm", "dlx", tarballSpec, ...args),
-      Command.workingDirectory(projectRoot)
-    )
-    yield* _(runCommand(command))
-  })
-
-const assertCopied = (root: string, destDir: string) =>
-  withFsPath((fs, path) =>
-    Effect.gen(function*(_) {
-      const codexFile = path.join(destDir, "sessions/2025/11/cli.jsonl")
-      const codexExists = yield* _(fs.exists(codexFile))
-      expect(codexExists).toBe(true)
-
-      const qwenFile = path.join(root, ".knowledge", ".qwen", "session-1.json")
-      const qwenExists = yield* _(fs.exists(qwenFile))
-      expect(qwenExists).toBe(true)
-    })
-  )
-
-describe("cli package execution", () => {
-  it.effect("packs the CLI and executes it via npx", () =>
-    Effect.scoped(
-      Effect.gen(function*(_) {
-        const { tarballSpec } = yield* _(packCli)
-        const { codexSource, destDir, qwenSource, root } = yield* _(
-          prepareProject
-        )
-        yield* _(
-          runCliWithRunner({
-            runner: "npx",
-            tarballSpec,
-            root,
-            codexSource,
-            destDir,
-            qwenSource
-          })
-        )
-        yield* _(assertCopied(root, destDir))
-        const second = yield* _(prepareProject)
-        yield* _(
-          runCliWithRunner({
-            runner: "pnpm-dlx",
-            tarballSpec,
-            root: second.root,
-            codexSource: second.codexSource,
-            destDir: second.destDir,
-            qwenSource: second.qwenSource
-          })
-        )
-        yield* _(assertCopied(second.root, second.destDir))
-      })
-    ).pipe(
-      Effect.provide(Layer.mergeAll(NodeContext.layer))
-    ), 30_000)
-})

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

@@ -1,203 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,19 +0,0 @@
-{
-	"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"]
-}