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

package/package.json

@@ -1,62 +1,93 @@
 {
   "name": "@prover-coder-ai/context-doc",
-  "version": "1.0.12",
-  "description": "",
-  "type": "module",
-  "scripts": {
-    "start": "tsx src/main.ts",
-    "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 lint && npm run build && npm version patch && npm publish --access public"
-  },
+  "version": "1.0.13",
+  "description": "Minimal Vite-powered TypeScript console starter using Effect",
+  "main": "dist/main.js",
   "bin": {
-    "context-doc": "dist/shell/cli.js"
+    "context-doc": "bin/context-doc.js"
+  },
+  "directories": {
+    "doc": "doc"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/prover-coder-ai/context-doc.git"
+    "url": "git+https://github.com/ProverCoderAI/context-doc.git"
   },
-  "keywords": [],
+  "keywords": [
+    "effect",
+    "typescript",
+    "vite",
+    "console"
+  ],
   "author": "",
   "license": "ISC",
+  "type": "module",
   "bugs": {
-    "url": "https://github.com/prover-coder-ai/context-doc/issues"
+    "url": "https://github.com/ProverCoderAI/context-doc/issues"
   },
-  "homepage": "https://github.com/prover-coder-ai/context-doc#readme",
-  "files": [
-    "dist",
-    "src",
-    "doc",
-    "README.md",
-    "tsconfig.build.json",
-    "vitest.config.ts"
-  ],
+  "homepage": "https://github.com/ProverCoderAI/context-doc#readme",
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
+    "@effect/cli": "^0.73.0",
+    "@effect/cluster": "^0.56.1",
+    "@effect/experimental": "^0.58.0",
+    "@effect/platform": "^0.94.1",
+    "@effect/platform-node": "^0.104.0",
+    "@effect/printer": "^0.47.0",
+    "@effect/printer-ansi": "^0.47.0",
+    "@effect/rpc": "^0.73.0",
     "@effect/schema": "^0.75.5",
-    "effect": "^3.19.6",
-    "ts-morph": "^27.0.2",
-    "ts-pattern": "^5.9.0",
-    "vite-tsconfig-paths": "^5.1.4"
+    "@effect/sql": "^0.49.0",
+    "@effect/typeclass": "^0.38.0",
+    "@effect/workflow": "^0.16.0",
+    "effect": "^3.19.14",
+    "ts-morph": "^27.0.2"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.3.7",
-    "@eslint-community/eslint-plugin-eslint-comments": "^4.5.0",
-    "@eslint/js": "^9.39.1",
-    "@ton-ai-core/eslint-plugin-suggest-members": "^1.6.17",
+    "@biomejs/biome": "^2.3.11",
+    "@effect/eslint-plugin": "^0.3.2",
+    "@effect/language-service": "latest",
+    "@effect/vitest": "^0.27.0",
+    "@eslint-community/eslint-plugin-eslint-comments": "^4.6.0",
+    "@eslint/compat": "2.0.1",
+    "@eslint/eslintrc": "3.3.3",
+    "@eslint/js": "9.39.2",
+    "@prover-coder-ai/eslint-plugin-suggest-members": "^0.0.13",
     "@ton-ai-core/vibecode-linter": "^1.0.6",
-    "@types/node": "^24.10.1",
-    "eslint": "^9.39.1",
-    "eslint-plugin-vitest": "^0.5.4",
-    "globals": "^16.5.0",
-    "tsx": "^4.20.6",
+    "@types/node": "^24.10.9",
+    "@typescript-eslint/eslint-plugin": "^8.53.0",
+    "@typescript-eslint/parser": "^8.53.0",
+    "@vitest/coverage-v8": "^4.0.17",
+    "@vitest/eslint-plugin": "^1.6.6",
+    "eslint": "^9.39.2",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-codegen": "0.34.1",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "eslint-plugin-sonarjs": "^3.0.5",
+    "eslint-plugin-sort-destructure-keys": "^2.0.0",
+    "eslint-plugin-unicorn": "^62.0.0",
+    "fast-check": "^4.5.3",
+    "globals": "^17.0.0",
+    "jscpd": "^4.0.7",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.48.0",
-    "vitest": "^4.0.14"
+    "typescript-eslint": "^8.53.0",
+    "vite": "^7.3.1",
+    "vite-tsconfig-paths": "^6.0.4",
+    "vitest": "^4.0.17"
+  },
+  "scripts": {
+    "build": "vite build --ssr src/app/main.ts",
+    "dev": "vite build --watch --ssr src/app/main.ts",
+    "lint": "npx @ton-ai-core/vibecode-linter src/",
+    "lint:tests": "npx @ton-ai-core/vibecode-linter tests/",
+    "lint:effect": "npx eslint --config eslint.effect-ts-check.config.mjs .",
+    "check": "pnpm run typecheck",
+    "prestart": "pnpm run build",
+    "start": "node dist/main.js -- --project-root ../..",
+    "test": "pnpm run lint:tests && vitest run",
+    "typecheck": "tsc --noEmit"
   }
-}
+}

package/src/app/main.ts

@@ -0,0 +1,29 @@
+import { NodeContext, NodeRuntime } from "@effect/platform-node"
+import { Effect, Layer, pipe } from "effect"
+
+import { CryptoServiceLive } from "../shell/services/crypto.js"
+import { FileSystemLive } from "../shell/services/file-system.js"
+import { RuntimeEnvLive } from "../shell/services/runtime-env.js"
+import { program } from "./program.js"
+
+// CHANGE: run the sync program through the Node runtime with all live layers
+// WHY: provide platform services and shell dependencies in one place
+// QUOTE(TZ): "SHELL: Все эффекты изолированы"
+// REF: user-2026-01-19-sync-rewrite
+// SOURCE: n/a
+// FORMAT THEOREM: forall env: provide(env) -> runMain(program)
+// PURITY: SHELL
+// EFFECT: Effect<void, never, RuntimeEnv | FileSystemService | CryptoService | Path>
+// INVARIANT: program executed with NodeContext + live services
+// COMPLEXITY: O(1)/O(1)
+const main = pipe(
+  program,
+  Effect.provide(
+    Layer.provideMerge(
+      Layer.mergeAll(RuntimeEnvLive, FileSystemLive, CryptoServiceLive),
+      NodeContext.layer
+    )
+  )
+)
+
+NodeRuntime.runMain(main)

package/src/app/program.ts

@@ -0,0 +1,32 @@
+import { Effect, pipe } from "effect"
+
+import { readSyncOptions } from "../shell/cli.js"
+import { buildSyncProgram } from "../shell/sync/index.js"
+
+/**
+ * Compose the knowledge sync CLI as a single effect.
+ *
+ * @returns Effect that runs multi-source sync in sequence.
+ *
+ * @pure false - reads argv and performs filesystem IO
+ * @effect RuntimeEnv, FileSystemService, CryptoService, Path
+ * @invariant forall opts: buildSyncProgram(opts) runs each source exactly once
+ * @precondition true
+ * @postcondition sources are synced or skipped with logs
+ * @complexity O(n) where n = number of files scanned
+ * @throws Never - all errors are typed in the Effect error channel
+ */
+// CHANGE: rewire program to knowledge-sync orchestration
+// WHY: replace greeting demo with the fully effectful sync pipeline
+// QUOTE(TZ): "Возьми прошлый ... код и перепиши его полностью"
+// REF: user-2026-01-19-sync-rewrite
+// SOURCE: n/a
+// FORMAT THEOREM: forall a: parse(a) -> run(sync(a))
+// PURITY: SHELL
+// EFFECT: Effect<void, never, RuntimeEnv | FileSystemService | CryptoService | Path>
+// INVARIANT: sync sources run in deterministic order
+// COMPLEXITY: O(n)/O(n)
+export const program = pipe(
+  readSyncOptions,
+  Effect.flatMap((options) => buildSyncProgram(options))
+)

package/src/core/knowledge.ts

@@ -1,139 +1,115 @@
-import path from "node:path";
-import { Option, pipe } from "effect";
+import { Option, pipe } from "effect"
 
-type JsonPrimitive = string | number | boolean | null;
-type JsonValue = JsonPrimitive | readonly JsonValue[] | JsonRecord;
-interface JsonRecord {
-	readonly [key: string]: JsonValue;
+export type JsonPrimitive = string | number | boolean | null
+export type JsonValue = JsonPrimitive | ReadonlyArray<JsonValue> | JsonRecord
+export interface JsonRecord {
+  readonly [key: string]: JsonValue
 }
 
 export interface ProjectLocator {
-	readonly normalizedRepositoryUrl: string;
-	readonly normalizedCwd: string;
+  readonly normalizedCwd: string
+  readonly isWithinRoot: (candidate: string) => boolean
 }
 
 interface RecordMetadata {
-	readonly repositoryUrl: Option.Option<string>;
-	readonly cwd: Option.Option<string>;
+  readonly cwd: Option.Option<string>
 }
 
 const isJsonRecord = (value: JsonValue): value is JsonRecord =>
-	typeof value === "object" && value !== null && !Array.isArray(value);
-
-const normalizeRepositoryUrl = (value: string): string =>
-	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: string): string => path.resolve(value);
+  typeof value === "object" && value !== null && !Array.isArray(value)
 
 const pickString = (record: JsonRecord, key: string): Option.Option<string> => {
-	const candidate = record[key];
-	return typeof candidate === "string" ? Option.some(candidate) : Option.none();
-};
-
-const pickRecord = (
-	record: JsonRecord,
-	key: string,
-): Option.Option<JsonRecord> =>
-	pipe(record[key], Option.fromNullable, Option.filter(isJsonRecord));
-
-const pickGitRepository = (record: JsonRecord): Option.Option<string> =>
-	pipe(
-		pickString(record, "repository_url"),
-		Option.orElse(() => pickString(record, "repositoryUrl")),
-	);
+  const candidate = record[key]
+  return Option.fromNullable(typeof candidate === "string" ? candidate : null)
+}
 
-const extractRepository = (record: JsonRecord): Option.Option<string> =>
-	pipe(
-		pickRecord(record, "git"),
-		Option.flatMap(pickGitRepository),
-		Option.orElse(() =>
-			pipe(
-				pickRecord(record, "payload"),
-				Option.flatMap((payload) =>
-					pipe(pickRecord(payload, "git"), Option.flatMap(pickGitRepository)),
-				),
-			),
-		),
-	);
+const pickRecord = (record: JsonRecord, key: string): Option.Option<JsonRecord> =>
+  pipe(
+    record[key],
+    Option.fromNullable,
+    Option.filter((value) => isJsonRecord(value))
+  )
 
 const extractCwd = (record: JsonRecord): Option.Option<string> =>
-	pipe(
-		pickString(record, "cwd"),
-		Option.orElse(() =>
-			pipe(
-				pickRecord(record, "payload"),
-				Option.flatMap((payload) => pickString(payload, "cwd")),
-			),
-		),
-	);
+  pipe(
+    pickString(record, "cwd"),
+    Option.orElse(() =>
+      pipe(
+        pickRecord(record, "payload"),
+        Option.flatMap((payload) => pickString(payload, "cwd"))
+      )
+    )
+  )
 
 const toMetadata = (value: JsonValue): RecordMetadata => {
-	if (!isJsonRecord(value)) {
-		return { repositoryUrl: Option.none(), cwd: Option.none() };
-	}
-
-	return {
-		repositoryUrl: extractRepository(value),
-		cwd: extractCwd(value),
-	};
-};
+  if (!isJsonRecord(value)) {
+    return { cwd: Option.none() }
+  }
 
-const normalizeLocator = (
-	repositoryUrl: string,
-	cwd: string,
-): ProjectLocator => ({
-	normalizedRepositoryUrl: normalizeRepositoryUrl(repositoryUrl),
-	normalizedCwd: normalizeCwd(cwd),
-});
+  return {
+    cwd: extractCwd(value)
+  }
+}
 
-const safeParseJson = (line: string): Option.Option<JsonValue> => {
-	try {
-		return Option.some(JSON.parse(line));
-	} catch {
-		return Option.none();
-	}
-};
+const cwdMatches = (metadata: RecordMetadata, locator: ProjectLocator): boolean =>
+  Option.exists(metadata.cwd, (cwdValue) => locator.isWithinRoot(cwdValue))
 
 const metadataMatches = (
-	metadata: RecordMetadata,
-	locator: ProjectLocator,
-): boolean => {
-	const cwdMatches = Option.exists(metadata.cwd, (cwdValue) => {
-		const normalized = normalizeCwd(cwdValue);
-		return normalized === locator.normalizedCwd;
-	});
-
-	return cwdMatches;
-};
-
+  metadata: RecordMetadata,
+  locator: ProjectLocator
+): boolean => cwdMatches(metadata, locator)
+
+/**
+ * Builds a locator for matching project-scoped metadata.
+ *
+ * @param normalizedCwd - Pre-normalized cwd of the project root.
+ * @param isWithinRoot - Pure predicate for checking candidate cwd membership.
+ * @returns Locator values for project comparisons.
+ *
+ * @pure true
+ * @invariant normalizedCwd is absolute and stable for equal inputs
+ * @complexity O(1) time / O(1) space
+ */
+// CHANGE: bundle normalized root and pure membership predicate in a locator
+// WHY: keep matching invariants in CORE and leave path normalization in SHELL
+// QUOTE(TZ): "FUNCTIONAL CORE, IMPERATIVE SHELL"
+// REF: user-2026-01-19-sync-rewrite
+// SOURCE: n/a
+// FORMAT THEOREM: forall c: locator(c) -> membership(c)
+// PURITY: CORE
+// EFFECT: n/a
+// INVARIANT: normalizedCwd is absolute and stable for equal inputs
+// COMPLEXITY: O(1)/O(1)
 export const buildProjectLocator = (
-	repositoryUrl: string,
-	cwd: string,
-): ProjectLocator => normalizeLocator(repositoryUrl, cwd);
-
-export const linesMatchProject = (
-	lines: readonly string[],
-	locator: ProjectLocator,
-): boolean =>
-	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)),
-		);
-	});
+  normalizedCwd: string,
+  isWithinRoot: (candidate: string) => boolean
+): ProjectLocator => ({
+  normalizedCwd,
+  isWithinRoot
+})
+
+/**
+ * Checks whether a parsed JSON value contains project metadata.
+ *
+ * @param value - Parsed JSON value from a .jsonl line.
+ * @param locator - Normalized project locator.
+ * @returns True when cwd matches the project root.
+ *
+ * @pure true
+ * @invariant valueMatchesProject implies metadataMatches for extracted metadata
+ * @complexity O(k) where k = number of metadata fields read
+ */
+// CHANGE: restrict project matching to cwd-only semantics
+// WHY: align with project-local path matching requirement
+// QUOTE(TZ): "каждая функция — теорема"
+// REF: user-2026-01-19-sync-rewrite
+// SOURCE: n/a
+// FORMAT THEOREM: forall v: JsonValue -> matches(v, locator) <-> metadataMatches(v)
+// PURITY: CORE
+// EFFECT: n/a
+// INVARIANT: metadataMatches uses cwd evidence only
+// COMPLEXITY: O(k)/O(1)
+export const valueMatchesProject = (
+  value: JsonValue,
+  locator: ProjectLocator
+): boolean => metadataMatches(toMetadata(value), locator)

package/src/shell/cli.ts

@@ -1,7 +1,75 @@
-#!/usr/bin/env node
-import { Effect } from "effect";
-import { buildSyncProgram, parseArgs } from "./syncKnowledge.js";
+import { Effect } from "effect"
 
-const program = buildSyncProgram(parseArgs());
+import { RuntimeEnv } from "./services/runtime-env.js"
+import type { SyncOptions } from "./sync/types.js"
 
-Effect.runSync(program);
+type CliKey = Exclude<keyof SyncOptions, "cwd">
+
+const flagMap = new Map<string, CliKey>([
+  ["--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: ReadonlyArray<string>, cwd: string): SyncOptions => {
+  let result: SyncOptions = { cwd }
+
+  let index = 0
+  while (index < args.length) {
+    const arg = args[index]
+    if (arg === undefined) {
+      index += 1
+      continue
+    }
+    const key = flagMap.get(arg)
+    if (key === undefined) {
+      index += 1
+      continue
+    }
+
+    const value = args[index + 1]
+    if (value !== undefined) {
+      result = { ...result, [key]: value }
+      index += 2
+      continue
+    }
+    index += 1
+  }
+
+  return result
+}
+
+/**
+ * Reads CLI arguments and builds SyncOptions.
+ *
+ * @returns Effect with resolved SyncOptions.
+ *
+ * @pure false - reads process argv/cwd via RuntimeEnv
+ * @effect RuntimeEnv
+ * @invariant options.cwd is always defined; projectRoot overrides cwd for matching
+ * @complexity O(n) where n = |args|
+ */
+// CHANGE: parse CLI flags with optional project root override
+// WHY: allow matching against repo root while running from subpackages
+// QUOTE(TZ): "передай root-path на основную папку"
+// REF: user-2026-01-19-project-root
+// SOURCE: n/a
+// FORMAT THEOREM: forall a: parse(a) -> SyncOptions
+// PURITY: SHELL
+// EFFECT: Effect<SyncOptions, never, RuntimeEnv>
+// INVARIANT: unknown flags are ignored
+// COMPLEXITY: O(n)/O(1)
+export 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)
+})

package/src/shell/services/crypto.ts

@@ -0,0 +1,50 @@
+import { Context, Effect, Layer, pipe } from "effect"
+
+export class CryptoService extends Context.Tag("CryptoService")<
+  CryptoService,
+  {
+    readonly sha256: (value: string) => Effect.Effect<string, CryptoError>
+  }
+>() {}
+
+export interface CryptoError {
+  readonly _tag: "CryptoError"
+  readonly reason: string
+}
+
+const cryptoError = (reason: string): CryptoError => ({
+  _tag: "CryptoError",
+  reason
+})
+
+const toHex = (buffer: ArrayBuffer): string =>
+  [...new Uint8Array(buffer)]
+    .map((byte) => byte.toString(16).padStart(2, "0"))
+    .join("")
+
+const digestSha256 = (value: string): Effect.Effect<string, CryptoError> =>
+  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))
+  )
+
+// CHANGE: isolate hashing behind a service for deterministic testing
+// WHY: avoid direct crypto usage in shell logic
+// QUOTE(TZ): "Внешние зависимости: только через типизированные интерфейсы"
+// REF: user-2026-01-19-sync-rewrite
+// SOURCE: n/a
+// FORMAT THEOREM: forall s: sha256(s) -> hex(s)
+// PURITY: SHELL
+// EFFECT: Effect<CryptoService, never, never>
+// INVARIANT: sha256 output length = 64
+// COMPLEXITY: O(n)/O(1)
+export const CryptoServiceLive = Layer.succeed(CryptoService, {
+  sha256: (value) => digestSha256(value)
+})