@prover-coder-ai/context-doc 1.0.4

package/README.md

@@ -0,0 +1,19 @@
+# Knowledge Sync CLI
+
+Command: `npm run sync:knowledge` (or `tsx src/shell/syncKnowledge.ts`) — copies only dialogs that belong to the current project into `.knowledge/.codex`.
+
+## Flags
+- `--source, -s <path>` — explicit path to `.codex`.
+- `--dest, -d <path>` — destination root (defaults to `.knowledge/.codex` in the project).
+- `--project-url` / `--project-name <url>` — override repository URL (otherwise read from `package.json`).
+- `--meta-root <path>` — path to a meta folder; if it’s not already `.codex`, the tool looks for `<meta-root>/.codex`.
+
+## `.codex` lookup order
+1) `--source` (if provided)  
+2) env `CODEX_SOURCE_DIR`  
+3) `--meta-root` (either the `.codex` itself or `<meta-root>/.codex`)  
+4) project-local `.codex`  
+5) home `~/.codex`
+
+Only `.jsonl` files whose `git.repository_url` or `cwd` match this project are copied.\
+Copies are placed under `.knowledge/.codex` preserving the directory structure.

package/dist/core/greeting.js

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

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

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

@@ -0,0 +1,119 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import * as S from "@effect/schema/Schema";
+import { Console, Effect, pipe } from "effect";
+import { buildProjectLocator, linesMatchProject } from "../core/knowledge.js";
+import { ensureDirectory, syncError } from "./syncShared.js";
+const PackageRepositorySchema = S.Struct({
+    url: S.String,
+});
+const PackageFileSchema = S.Struct({
+    repository: S.optional(PackageRepositorySchema),
+});
+const PackageFileFromJson = S.compose(S.parseJson(), PackageFileSchema);
+const decodePackageFile = S.decodeUnknownSync(PackageFileFromJson);
+const readRepositoryUrl = (cwd, repositoryUrlOverride) => Effect.try({
+    try: () => {
+        if (repositoryUrlOverride !== undefined) {
+            return repositoryUrlOverride;
+        }
+        const raw = fs.readFileSync(path.join(cwd, "package.json"), "utf8");
+        const parsed = decodePackageFile(raw);
+        const repositoryUrl = parsed.repository?.url;
+        if (repositoryUrl === undefined) {
+            throw new Error("repository url is missing");
+        }
+        return repositoryUrl;
+    },
+    catch: () => syncError("package.json", "Cannot read repository url"),
+});
+const resolveSourceDir = (cwd, override, metaRoot) => Effect.try({
+    try: () => {
+        const envSource = process.env.CODEX_SOURCE_DIR;
+        const metaCandidate = metaRoot === undefined
+            ? undefined
+            : metaRoot.endsWith(".codex")
+                ? metaRoot
+                : path.join(metaRoot, ".codex");
+        const localSource = path.join(cwd, ".codex");
+        const homeSource = path.join(os.homedir(), ".codex");
+        const candidates = [
+            override,
+            envSource,
+            metaCandidate,
+            localSource,
+            homeSource,
+        ];
+        const existing = candidates.find((candidate) => candidate !== undefined && fs.existsSync(candidate));
+        if (existing === undefined) {
+            throw new Error("source .codex not found");
+        }
+        return existing;
+    },
+    catch: () => syncError(".codex", "Source .codex directory is missing"),
+});
+const collectJsonlFiles = (root) => Effect.try({
+    try: () => {
+        const collected = [];
+        const walk = (current) => {
+            const entries = fs.readdirSync(current, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(current, entry.name);
+                if (entry.isDirectory()) {
+                    walk(fullPath);
+                }
+                else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+                    collected.push(fullPath);
+                }
+            }
+        };
+        walk(root);
+        return collected;
+    },
+    catch: () => syncError(root, "Cannot traverse .codex"),
+});
+const isFileRelevant = (filePath, locator) => Effect.try({
+    try: () => {
+        const content = fs.readFileSync(filePath, "utf8");
+        const lines = content.split("\n");
+        return linesMatchProject(lines, locator);
+    },
+    catch: () => syncError(filePath, "Cannot read jsonl file"),
+});
+const copyRelevantFile = (sourceRoot, destinationRoot, filePath) => Effect.try({
+    try: () => {
+        const relative = path.relative(sourceRoot, filePath);
+        const targetPath = path.join(destinationRoot, relative);
+        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+        fs.copyFileSync(filePath, targetPath);
+    },
+    catch: () => syncError(filePath, "Cannot copy file into .knowledge/.codex"),
+});
+const selectRelevantFiles = (files, locator) => Effect.reduce(files, [], (acc, filePath) => pipe(isFileRelevant(filePath, locator), Effect.map((isRelevant) => {
+    if (isRelevant) {
+        acc.push(filePath);
+    }
+    return acc;
+})));
+// CHANGE: Extract Codex dialog sync into dedicated module for clarity.
+// WHY: Separate Codex-specific shell effects from other sync flows.
+// QUOTE(ТЗ): "вынеси в отдельный файл"
+// REF: user request 2025-11-26
+// SOURCE: internal requirement
+// FORMAT THEOREM: ∀f ∈ Files: relevant(f, locator) → copied(f, destination)
+// PURITY: SHELL
+// EFFECT: Effect<void, SyncError, never>
+// INVARIANT: ∀f ∈ copiedFiles: linesMatchProject(f, locator)
+// COMPLEXITY: O(n) time / O(n) space, n = |files|
+export const syncCodex = (options) => Effect.gen(function* (_) {
+    const repositoryUrl = yield* _(readRepositoryUrl(options.cwd, options.repositoryUrlOverride));
+    const sourceDir = yield* _(resolveSourceDir(options.cwd, options.sourceDir, options.metaRoot));
+    const destinationDir = options.destinationDir ?? path.join(options.cwd, ".knowledge", ".codex");
+    yield* _(ensureDirectory(destinationDir));
+    const locator = buildProjectLocator(repositoryUrl, options.cwd);
+    const allJsonlFiles = yield* _(collectJsonlFiles(sourceDir));
+    const relevantFiles = yield* _(selectRelevantFiles(allJsonlFiles, locator));
+    yield* _(Effect.forEach(relevantFiles, (filePath) => copyRelevantFile(sourceDir, destinationDir, filePath)));
+    yield* _(Console.log(`Synced ${relevantFiles.length} dialog files into .knowledge/.codex`));
+});

package/dist/shell/qwenSync.js

@@ -0,0 +1,49 @@
+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"),
+});
+const qwenHashFromPath = (projectPath) => createHash("sha256").update(projectPath).digest("hex");
+const resolveQwenSourceDir = (cwd, override, metaRoot) => pipe(Effect.sync(() => {
+    const hash = qwenHashFromPath(cwd);
+    const envSource = process.env.QWEN_SOURCE_DIR;
+    const baseFromMeta = metaRoot === undefined
+        ? undefined
+        : metaRoot.endsWith(".qwen")
+            ? metaRoot
+            : path.join(metaRoot, ".qwen");
+    const homeBase = path.join(os.homedir(), ".qwen");
+    const candidates = [
+        override,
+        envSource,
+        baseFromMeta ? path.join(baseFromMeta, "tmp", hash) : undefined,
+        path.join(cwd, ".qwen", "tmp", hash),
+        path.join(homeBase, "tmp", hash),
+    ];
+    return candidates.find((candidate) => candidate !== undefined && fs.existsSync(candidate));
+}), Effect.flatMap((found) => found === undefined
+    ? Effect.fail(syncError(".qwen", "Qwen source directory is missing"))
+    : Effect.succeed(found)));
+export const syncQwen = (options) => pipe(resolveQwenSourceDir(options.cwd, options.qwenSourceDir, options.metaRoot), Effect.flatMap((qwenSource) => pipe(ensureDirectory(path.join(options.cwd, ".knowledge", ".qwen")), Effect.flatMap(() => copyDirectoryJsonOnly(qwenSource, path.join(options.cwd, ".knowledge", ".qwen"))), Effect.flatMap((copiedCount) => Console.log(`Synced ${copiedCount} Qwen dialog files into .knowledge/.qwen`)))), Effect.catchAll(() => Console.log("Qwen source not found; skipped syncing Qwen dialog files")));

package/dist/shell/syncKnowledge.js

@@ -0,0 +1,47 @@
+import { pathToFileURL } from "node:url";
+import { Effect } from "effect";
+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* _(syncCodex(options));
+    yield* _(syncQwen(options));
+});
+const isMainModule = () => {
+    const entry = process.argv[1];
+    if (entry === undefined) {
+        return false;
+    }
+    return import.meta.url === pathToFileURL(entry).href;
+};
+const parseArgs = () => {
+    const argv = process.argv.slice(2);
+    let result = { cwd: process.cwd() };
+    const mapping = {
+        "--source": "sourceDir",
+        "-s": "sourceDir",
+        "--dest": "destinationDir",
+        "-d": "destinationDir",
+        "--project-url": "repositoryUrlOverride",
+        "--project-name": "repositoryUrlOverride",
+        "--meta-root": "metaRoot",
+        "--qwen-source": "qwenSourceDir",
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        const key = mapping[arg];
+        if (key === undefined) {
+            continue;
+        }
+        const value = argv[i + 1];
+        if (value !== undefined) {
+            result = { ...result, [key]: value };
+            i++;
+        }
+    }
+    return result;
+};
+if (isMainModule()) {
+    const program = buildSyncProgram(parseArgs());
+    Effect.runSync(program);
+}

package/dist/shell/syncShared.js

@@ -0,0 +1,13 @@
+import fs from "node:fs";
+import { Effect } from "effect";
+export const syncError = (pathValue, reason) => ({
+    _tag: "SyncError",
+    path: pathValue,
+    reason,
+});
+export const ensureDirectory = (directory) => Effect.try({
+    try: () => {
+        fs.mkdirSync(directory, { recursive: true });
+    },
+    catch: () => syncError(directory, "Cannot create destination directory structure"),
+});

package/dist/shell/syncTypes.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@prover-coder-ai/context-doc",
+  "version": "1.0.4",
+  "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",
+    "sync:knowledge": "tsx src/shell/syncKnowledge.ts",
+    "release": "npm run build && npm run lint && npm version patch && npm publish --access public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/prover-coder-ai/context-doc.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/prover-coder-ai/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"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@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"
+  },
+  "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",
+    "@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",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.48.0",
+    "vitest": "^4.0.14"
+  }
+}

package/src/core/greeting.ts

@@ -0,0 +1,39 @@
+import { Option } from "effect";
+
+export interface AppProfile {
+	readonly name: string;
+	readonly mission: string;
+}
+
+export interface Greeting {
+	readonly message: string;
+}
+
+const normalize = (value: string): string => value.trim();
+
+const isNonEmpty = (value: string): boolean => 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: AppProfile): Option.Option<Greeting> => {
+	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/src/core/knowledge.ts

@@ -0,0 +1,148 @@
+import path from "node:path";
+import { Option, pipe } from "effect";
+
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | readonly JsonValue[] | JsonRecord;
+interface JsonRecord {
+	readonly [key: string]: JsonValue;
+}
+
+export interface ProjectLocator {
+	readonly normalizedRepositoryUrl: string;
+	readonly normalizedCwd: string;
+}
+
+interface RecordMetadata {
+	readonly repositoryUrl: 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);
+
+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 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 extractCwd = (record: JsonRecord): Option.Option<string> =>
+	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),
+	};
+};
+
+const normalizeLocator = (
+	repositoryUrl: string,
+	cwd: string,
+): ProjectLocator => ({
+	normalizedRepositoryUrl: normalizeRepositoryUrl(repositoryUrl),
+	normalizedCwd: normalizeCwd(cwd),
+});
+
+const safeParseJson = (line: string): Option.Option<JsonValue> => {
+	try {
+		return Option.some(JSON.parse(line));
+	} catch {
+		return Option.none();
+	}
+};
+
+const metadataMatches = (
+	metadata: RecordMetadata,
+	locator: ProjectLocator,
+): boolean => {
+	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 repoMatches || cwdMatches;
+};
+
+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)),
+		);
+	});

package/src/main.ts

@@ -0,0 +1,49 @@
+import { Console, Effect, Option, pipe } from "effect";
+import { match } from "ts-pattern";
+import type { AppProfile } from "./core/greeting.js";
+import { buildGreeting } from "./core/greeting.js";
+
+interface StartupError {
+	readonly _tag: "StartupError";
+	readonly reason: string;
+}
+
+const appProfile: AppProfile = {
+	name: "Context Console",
+	mission: "Functional core ready for verifiable effects",
+};
+
+const toStartupError = (reason: string): StartupError => ({
+	_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/src/shell/codexSync.ts

@@ -0,0 +1,189 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import * as S from "@effect/schema/Schema";
+import { Console, Effect, pipe } from "effect";
+import type { ProjectLocator } from "../core/knowledge.js";
+import { buildProjectLocator, linesMatchProject } from "../core/knowledge.js";
+import { ensureDirectory, syncError } from "./syncShared.js";
+import type { SyncError, SyncOptions } from "./syncTypes.js";
+
+const PackageRepositorySchema = S.Struct({
+	url: S.String,
+});
+
+const PackageFileSchema = S.Struct({
+	repository: S.optional(PackageRepositorySchema),
+});
+const PackageFileFromJson = S.compose(S.parseJson(), PackageFileSchema);
+const decodePackageFile = S.decodeUnknownSync(PackageFileFromJson);
+
+const readRepositoryUrl = (
+	cwd: string,
+	repositoryUrlOverride?: string,
+): Effect.Effect<string, SyncError> =>
+	Effect.try({
+		try: () => {
+			if (repositoryUrlOverride !== undefined) {
+				return repositoryUrlOverride;
+			}
+
+			const raw = fs.readFileSync(path.join(cwd, "package.json"), "utf8");
+			const parsed = decodePackageFile(raw);
+			const repositoryUrl = parsed.repository?.url;
+
+			if (repositoryUrl === undefined) {
+				throw new Error("repository url is missing");
+			}
+
+			return repositoryUrl;
+		},
+		catch: () => syncError("package.json", "Cannot read repository url"),
+	});
+
+const resolveSourceDir = (
+	cwd: string,
+	override?: string,
+	metaRoot?: string,
+): Effect.Effect<string, SyncError> =>
+	Effect.try({
+		try: () => {
+			const envSource = process.env.CODEX_SOURCE_DIR;
+			const metaCandidate =
+				metaRoot === undefined
+					? undefined
+					: metaRoot.endsWith(".codex")
+						? metaRoot
+						: path.join(metaRoot, ".codex");
+			const localSource = path.join(cwd, ".codex");
+			const homeSource = path.join(os.homedir(), ".codex");
+			const candidates = [
+				override,
+				envSource,
+				metaCandidate,
+				localSource,
+				homeSource,
+			];
+			const existing = candidates.find(
+				(candidate) => candidate !== undefined && fs.existsSync(candidate),
+			);
+
+			if (existing === undefined) {
+				throw new Error("source .codex not found");
+			}
+
+			return existing;
+		},
+		catch: () => syncError(".codex", "Source .codex directory is missing"),
+	});
+
+const collectJsonlFiles = (
+	root: string,
+): Effect.Effect<ReadonlyArray<string>, SyncError> =>
+	Effect.try({
+		try: () => {
+			const collected: string[] = [];
+			const walk = (current: string): void => {
+				const entries = fs.readdirSync(current, { withFileTypes: true });
+				for (const entry of entries) {
+					const fullPath = path.join(current, entry.name);
+					if (entry.isDirectory()) {
+						walk(fullPath);
+					} else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+						collected.push(fullPath);
+					}
+				}
+			};
+
+			walk(root);
+			return collected;
+		},
+		catch: () => syncError(root, "Cannot traverse .codex"),
+	});
+
+const isFileRelevant = (
+	filePath: string,
+	locator: ProjectLocator,
+): Effect.Effect<boolean, SyncError> =>
+	Effect.try({
+		try: () => {
+			const content = fs.readFileSync(filePath, "utf8");
+			const lines = content.split("\n");
+			return linesMatchProject(lines, locator);
+		},
+		catch: () => syncError(filePath, "Cannot read jsonl file"),
+	});
+
+const copyRelevantFile = (
+	sourceRoot: string,
+	destinationRoot: string,
+	filePath: string,
+): Effect.Effect<void, SyncError> =>
+	Effect.try({
+		try: () => {
+			const relative = path.relative(sourceRoot, filePath);
+			const targetPath = path.join(destinationRoot, relative);
+			fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+			fs.copyFileSync(filePath, targetPath);
+		},
+		catch: () => syncError(filePath, "Cannot copy file into .knowledge/.codex"),
+	});
+
+const selectRelevantFiles = (
+	files: ReadonlyArray<string>,
+	locator: ProjectLocator,
+): Effect.Effect<ReadonlyArray<string>, SyncError> =>
+	Effect.reduce(files, [] as string[], (acc, filePath) =>
+		pipe(
+			isFileRelevant(filePath, locator),
+			Effect.map((isRelevant) => {
+				if (isRelevant) {
+					acc.push(filePath);
+				}
+
+				return acc;
+			}),
+		),
+	);
+
+// CHANGE: Extract Codex dialog sync into dedicated module for clarity.
+// WHY: Separate Codex-specific shell effects from other sync flows.
+// QUOTE(ТЗ): "вынеси в отдельный файл"
+// REF: user request 2025-11-26
+// SOURCE: internal requirement
+// FORMAT THEOREM: ∀f ∈ Files: relevant(f, locator) → copied(f, destination)
+// PURITY: SHELL
+// EFFECT: Effect<void, SyncError, never>
+// INVARIANT: ∀f ∈ copiedFiles: linesMatchProject(f, locator)
+// COMPLEXITY: O(n) time / O(n) space, n = |files|
+export const syncCodex = (
+	options: SyncOptions,
+): Effect.Effect<void, SyncError> =>
+	Effect.gen(function* (_) {
+		const repositoryUrl = yield* _(
+			readRepositoryUrl(options.cwd, options.repositoryUrlOverride),
+		);
+		const sourceDir = yield* _(
+			resolveSourceDir(options.cwd, options.sourceDir, options.metaRoot),
+		);
+		const destinationDir =
+			options.destinationDir ?? path.join(options.cwd, ".knowledge", ".codex");
+
+		yield* _(ensureDirectory(destinationDir));
+
+		const locator = buildProjectLocator(repositoryUrl, options.cwd);
+		const allJsonlFiles = yield* _(collectJsonlFiles(sourceDir));
+		const relevantFiles = yield* _(selectRelevantFiles(allJsonlFiles, locator));
+
+		yield* _(
+			Effect.forEach(relevantFiles, (filePath) =>
+				copyRelevantFile(sourceDir, destinationDir, filePath),
+			),
+		);
+
+		yield* _(
+			Console.log(
+				`Synced ${relevantFiles.length} dialog files into .knowledge/.codex`,
+			),
+		);
+	});

package/src/shell/qwenSync.ts

@@ -0,0 +1,98 @@
+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"),
+	});
+
+const qwenHashFromPath = (projectPath: string): string =>
+	createHash("sha256").update(projectPath).digest("hex");
+
+const resolveQwenSourceDir = (
+	cwd: string,
+	override?: string,
+	metaRoot?: string,
+): Effect.Effect<string, SyncError> =>
+	pipe(
+		Effect.sync(() => {
+			const hash = qwenHashFromPath(cwd);
+			const envSource = process.env.QWEN_SOURCE_DIR;
+			const baseFromMeta =
+				metaRoot === undefined
+					? undefined
+					: metaRoot.endsWith(".qwen")
+						? metaRoot
+						: path.join(metaRoot, ".qwen");
+			const homeBase = path.join(os.homedir(), ".qwen");
+
+			const candidates = [
+				override,
+				envSource,
+				baseFromMeta ? path.join(baseFromMeta, "tmp", hash) : undefined,
+				path.join(cwd, ".qwen", "tmp", hash),
+				path.join(homeBase, "tmp", hash),
+			];
+
+			return candidates.find(
+				(candidate) => candidate !== undefined && fs.existsSync(candidate),
+			);
+		}),
+		Effect.flatMap((found) =>
+			found === undefined
+				? Effect.fail(syncError(".qwen", "Qwen source directory is missing"))
+				: Effect.succeed(found),
+		),
+	);
+
+export const syncQwen = (
+	options: SyncOptions,
+): Effect.Effect<void, SyncError> =>
+	pipe(
+		resolveQwenSourceDir(options.cwd, options.qwenSourceDir, options.metaRoot),
+		Effect.flatMap((qwenSource) =>
+			pipe(
+				ensureDirectory(path.join(options.cwd, ".knowledge", ".qwen")),
+				Effect.flatMap(() =>
+					copyDirectoryJsonOnly(
+						qwenSource,
+						path.join(options.cwd, ".knowledge", ".qwen"),
+					),
+				),
+				Effect.flatMap((copiedCount) =>
+					Console.log(
+						`Synced ${copiedCount} Qwen dialog files into .knowledge/.qwen`,
+					),
+				),
+			),
+		),
+		Effect.catchAll(() =>
+			Console.log("Qwen source not found; skipped syncing Qwen dialog files"),
+		),
+	);

package/src/shell/syncKnowledge.ts

@@ -0,0 +1,62 @@
+import { pathToFileURL } from "node:url";
+import { Effect } from "effect";
+import { syncCodex } from "./codexSync.js";
+import { syncQwen } from "./qwenSync.js";
+import type { SyncError, SyncOptions } from "./syncTypes.js";
+
+// PURPOSE: Sync project-scoped dialogs (Codex + Qwen) into .knowledge storage.
+export const buildSyncProgram = (
+	options: SyncOptions,
+): Effect.Effect<void, SyncError> =>
+	Effect.gen(function* (_) {
+		yield* _(syncCodex(options));
+		yield* _(syncQwen(options));
+	});
+
+const isMainModule = (): boolean => {
+	const entry = process.argv[1];
+
+	if (entry === undefined) {
+		return false;
+	}
+
+	return import.meta.url === pathToFileURL(entry).href;
+};
+
+const parseArgs = (): SyncOptions => {
+	const argv = process.argv.slice(2);
+	let result: SyncOptions = { cwd: process.cwd() };
+
+	const mapping: Readonly<Record<string, keyof SyncOptions>> = {
+		"--source": "sourceDir",
+		"-s": "sourceDir",
+		"--dest": "destinationDir",
+		"-d": "destinationDir",
+		"--project-url": "repositoryUrlOverride",
+		"--project-name": "repositoryUrlOverride",
+		"--meta-root": "metaRoot",
+		"--qwen-source": "qwenSourceDir",
+	};
+
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		const key = mapping[arg as keyof typeof mapping];
+		if (key === undefined) {
+			continue;
+		}
+
+		const value = argv[i + 1];
+		if (value !== undefined) {
+			result = { ...result, [key]: value };
+			i++;
+		}
+	}
+
+	return result;
+};
+
+if (isMainModule()) {
+	const program = buildSyncProgram(parseArgs());
+
+	Effect.runSync(program);
+}

package/src/shell/syncShared.ts

@@ -0,0 +1,20 @@
+import fs from "node:fs";
+import { Effect } from "effect";
+import type { SyncError } from "./syncTypes.js";
+
+export const syncError = (pathValue: string, reason: string): SyncError => ({
+	_tag: "SyncError",
+	path: pathValue,
+	reason,
+});
+
+export const ensureDirectory = (
+	directory: string,
+): Effect.Effect<void, SyncError> =>
+	Effect.try({
+		try: () => {
+			fs.mkdirSync(directory, { recursive: true });
+		},
+		catch: () =>
+			syncError(directory, "Cannot create destination directory structure"),
+	});

package/src/shell/syncTypes.ts

@@ -0,0 +1,14 @@
+export interface SyncError {
+	readonly _tag: "SyncError";
+	readonly path: string;
+	readonly reason: string;
+}
+
+export interface SyncOptions {
+	readonly cwd: string;
+	readonly sourceDir?: string;
+	readonly destinationDir?: string;
+	readonly repositoryUrlOverride?: string;
+	readonly metaRoot?: string;
+	readonly qwenSourceDir?: string;
+}

package/src/types/env.d.ts

@@ -0,0 +1,10 @@
+declare global {
+	namespace NodeJS {
+		interface ProcessEnv {
+			readonly CODEX_SOURCE_DIR?: string;
+			readonly QWEN_SOURCE_DIR?: string;
+		}
+	}
+}
+
+export {};

package/tsconfig.build.json

@@ -0,0 +1,18 @@
+{
+	// CHANGE: Emit compiled artifacts into dist instead of source tree
+	// WHY: Keep repository free of generated .js while still supporting production builds
+	// QUOTE(ТЗ): "FUNCTIONAL CORE, IMPERATIVE SHELL" — сборка отделена от исходников
+	// PURITY: SHELL (build configuration)
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		// ═══════════════════════════════════════════════════════════════════════════
+		// EMIT OVERRIDES (build-only)
+		// ═══════════════════════════════════════════════════════════════════════════
+		"noEmit": false,
+		"outDir": "dist",
+		"rootDir": "src",
+		"tsBuildInfoFile": "dist/.tsbuildinfo"
+	},
+	"include": ["src/**/*"],
+	"exclude": ["tests/**/*", "node_modules", "dist"]
+}

package/vitest.config.ts

@@ -0,0 +1,81 @@
+// CHANGE: Migrate from Jest to Vitest with mathematical equivalence
+// WHY: Faster execution, native ESM, Effect integration via @effect/vitest
+// QUOTE(ТЗ): "Проект использует Effect + функциональную парадигму"
+// REF: Migration from jest.config.mjs
+// PURITY: SHELL (configuration only)
+// INVARIANT: ∀ test: behavior_jest ≡ behavior_vitest
+// 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";
+
+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: Match Jest's test file patterns
+		// INVARIANT: Same test discovery as Jest
+		include: ["tests/**/*.{test,spec}.ts"],
+		exclude: ["node_modules", "dist", "dist-test"],
+
+		// 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: 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: 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: {
+			"@": "/src",
+		},
+	},
+});