monisess 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,85 @@
-# Temporary Holding Version
+# Monisess
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Память проекта для Claude Code: факты, задачи и журнал сессий лежат в репозитории
+(`.monisess/`, обычный markdown), поисковый индекс — локально. MCP-сервер по stdio
+плюс два хука: бриф в начале сессии и автоснимок перед сжатием контекста.
+
+Первый модуль будущего «мониторинга всего»: сущности (карточка, факт, задача, сессия)
+выбраны так, чтобы к ним потом подключались другие источники, а не только Claude.
+
+## Чем отличается от dedsession
+
+| | dedsession | Monisess |
+|---|---|---|
+| Единица знания | сессия (простыня из 15 полей) | факт — один файл; устаревший помечается `supersedes`, а не копится |
+| Хвосты | список внутри контекста | задача с id и статусом, дубли не плодятся |
+| Индекс | JSON в git → конфликты при merge | SQLite FTS5 в `~/.monisess/cache`, пересборка из файлов |
+| Правда о работе | что написала модель | плюс git: HEAD, коммиты и файлы с прошлой сессии — автоматически |
+| Сжатие контекста | ничего не знает | хук `PreCompact` снимает снимок; `SessionStart(compact)` дописывает сводку |
+| Описания инструментов | ~15 КБ уговоров в каждой сессии | 8 инструментов, ~5 КБ; правила приходят с брифом один раз |
+| Секреты | эвристика | вырезаются при любой записи, в отчёте — сколько |
+| Зависимости | — | только `@modelcontextprotocol/sdk` и `zod`; SQLite встроен в Node ≥ 22.5 |
+
+## Установка
+
+```bash
+npx -y monisess install
+```
+
+Ставит пакет глобально, подключает MCP-сервер на уровне пользователя и хуки SessionStart/PreCompact.
+Нужны Node ≥ 22.5 и Claude Code. Обновление — `npm install -g monisess`.
+
+Из исходников (для разработки): клон репозитория и `./install.sh` — собирает, делает `npm link` и `monisess install`.
+
+В проекте, где память нужна: `monisess import` (если есть `MD_HISTORY` от dedsession)
+или просто первый `save` из Claude. В проектах без `.monisess/` хуки молчат.
+
+Подробное руководство — [docs/GUIDE.md](docs/GUIDE.md): установка, подключение проектов,
+связь между проектами, формат файлов, диагностика.
+
+## Инструменты
+
+- `brief(topic?)` — карточка, git-дельта, открытые задачи, факты, последние сессии.
+- `save(title, summary, done?, decisions?, problems?, remaining?, facts?, close_tasks?, card?)`.
+- `recall(query | id)` — поиск (BM25, кириллица, префиксы) или запись целиком.
+- `fact` / `task` / `note` — точечные операции.
+- `projects()` — проекты с памятью на машине; `brief(project=…)`, `recall(scope=all)` — связь между ними.
+- `doctor(fix?)`, `import_md_history(source?, apply?)`.
+
+## Панель
+
+```bash
+monisess ui             # http://127.0.0.1:4620, только localhost
+```
+
+Обзор всех проектов с памятью (последняя сессия, открытые и протухшие задачи, коммиты,
+о которых в памяти ни слова), лента проекта — сессии вперемешку с коммитами git,
+задачи, факты с историей `supersedes`, поиск по всем проектам. Одна страница,
+без зависимостей и сетевых вызовов.
+
+### Захват мыслей
+
+На странице «Задачи» — поле ввода и выбор проекта: мысль ложится **в память этого
+проекта** (`.monisess/tasks/` или `notes.md`) тем же способом, каким пишет Claude,
+и поэтому сама всплывает в его брифе в начале следующей сессии. Отдельного списка
+дел у панели нет — хранилище одно. Захваченное за последние 7 дней видно и из
+брифов соседних проектов, чтобы мысль не ждала, пока откроют именно тот репозиторий.
+Кнопка «готово» закрывает задачу — то же, что `task(op=done)`.
+
+## Структура памяти
+
+```
+.monisess/
+  project.md            карточка проекта
+  facts/F001-….md       id, type (project|decision|lesson|rule|reference), status, tags, supersedes
+  tasks/T001-….md       status open|done|dropped, source — сессия, из которой задача
+  sessions/S001-….md    kind manual|auto|imported, head, branch, files; тело — Итог/Сделано/Решения/Проблемы/Осталось
+  notes.md              заметки на бегу; вливаются в следующую сессию
+```
+
+## Разработка
+
+```bash
+npm test          # node:test, без сборки
+npm run build     # tsc → dist/
+```

package/dist/brief.js

@@ -0,0 +1,186 @@
+import { commitsSince, gitState } from "./git.js";
+import { knownProjects } from "./registry.js";
+import { resolveProject } from "./paths.js";
+import { Store, sortTasks, today } from "./store.js";
+const DEFAULT_BUDGET = 14_000;
+export function buildBrief(store, index, opts = {}) {
+    const budget = opts.budget ?? DEFAULT_BUDGET;
+    const parts = [];
+    const name = store.project.name;
+    if (!store.exists()) {
+        return [
+            `# Память проекта ${name}: пусто`,
+            "",
+            "Папка `.monisess/` ещё не создана. Первый `save` создаст её; карточку проекта заполняет `save(card=…)`.",
+            gitHint(store),
+        ].join("\n");
+    }
+    const card = store.card();
+    // Карточка обычно начинается со своего заголовка — второй сверху не нужен.
+    parts.push(card.startsWith("# ") ? clip(card, Math.floor(budget * 0.25)) : `# ${name} — память проекта` + (card ? `\n\n${clip(card, Math.floor(budget * 0.25))}` : ""));
+    parts.push(gitSection(store));
+    const open = store.openTasks();
+    if (open.length) {
+        const sorted = sortTasks(open);
+        const lines = sorted.slice(0, 25).map((t) => `- ${taskLine(t)}`);
+        if (open.length > 25)
+            lines.push(`- … ещё ${open.length - 25}, см. task(op=list)`);
+        const overdue = open.filter((t) => t.due && t.due < today()).length;
+        const head = `## Открытые задачи (${open.length}${overdue ? `, просрочено ${overdue}` : ""})`;
+        parts.push(`${head}\n${lines.join("\n")}`);
+    }
+    // Страницы — только оглавлением: текст паспорта тянется по запросу page(title),
+    // иначе бриф и так за бюджетом (T009) раздулся бы ещё на десятки килобайт.
+    const pages = store.pages();
+    if (pages.length)
+        parts.push(`## Вики (${pages.length})\n${pages.map((p) => p.title).join(" · ")}\n_Прочитать: page(title=…)._`);
+    const notes = store.notes();
+    if (notes.length)
+        parts.push(`## Заметки на бегу\n${notes.map((n) => `- ${n}`).join("\n")}`);
+    const sessions = store.sessions();
+    const recent = sessions.slice(-3).reverse();
+    if (recent.length) {
+        parts.push(`## Последние сессии (всего ${sessions.length})\n` +
+            recent.map((s) => `### ${s.id} · ${s.date} · ${s.title}${s.kind === "auto" ? " (авто)" : ""}\n${tldr(s)}`).join("\n\n"));
+    }
+    const facts = store.facts().filter((f) => f.status === "active");
+    if (facts.length) {
+        const chosen = opts.topic ? rankedFacts(store, index, opts.topic, facts) : defaultFacts(facts);
+        const title = opts.topic ? `## Факты по теме «${opts.topic}»` : `## Факты (активных ${facts.length}${facts.length > chosen.length ? `, показаны ${chosen.length}` : ""})`;
+        parts.push(`${title}\n${chosen.map(formatFact).join("\n")}`);
+    }
+    if (opts.topic) {
+        const hits = index.search(opts.topic, { kind: "session", limit: 5 });
+        if (hits.length) {
+            parts.push(`## Сессии по теме «${opts.topic}»\n${hits.map((h) => `- ${h.id} · ${h.date} · ${h.title} — ${h.snippet}`).join("\n")}`);
+        }
+    }
+    const elsewhere = capturedElsewhere(store);
+    if (elsewhere)
+        parts.push(elsewhere);
+    const others = knownProjects().filter((e) => e.key !== store.project.key);
+    if (others.length)
+        parts.push(`## Другие проекты с памятью\n${others.map((e) => `- ${e.name} (был ${e.lastSeen}) — \`brief(project="${e.name}")\``).join("\n")}`);
+    parts.push("_Дальше: `recall(query)` — поиск по фактам и сессиям, `recall(id=S012)` — сессия целиком, " +
+        "`brief(topic=…)` — срез по теме. По окончании работы — `save`._");
+    return fit(parts, budget);
+}
+function gitSection(store) {
+    const git = gitState(store.project.root);
+    if (!git.available)
+        return "## Git\nне репозиторий";
+    const last = store.lastSession();
+    const lines = [`ветка ${git.branch}, HEAD ${git.head}${git.dirty.length ? `, незакоммичено: ${git.dirty.length}` : ""}`];
+    if (last?.head) {
+        const commits = commitsSince(store.project.root, last.head, 15);
+        if (commits === null)
+            lines.push(`с прошлой сессии (${last.id}, HEAD ${last.head}): коммит не найден в истории — возможно, другая ветка`);
+        else if (commits.length === 0)
+            lines.push(`с прошлой сессии (${last.id}) новых коммитов нет`);
+        else {
+            lines.push(`с прошлой сессии (${last.id}, ${last.date}) — ${commits.length}${commits.length === 15 ? "+" : ""} коммитов:`);
+            for (const c of commits)
+                lines.push(`  ${c.hash} ${c.date} ${c.subject}`);
+        }
+    }
+    return `## Git\n${lines.join("\n")}`;
+}
+/** Строка задачи: пометки словами, а не значками — их читает и человек, и модель. */
+export function taskLine(t) {
+    const flags = [];
+    if (t.status === "doing")
+        flags.push("в работе");
+    if (t.due)
+        flags.push(t.due < today() ? `срок ${t.due} — ПРОСРОЧЕНО` : `срок ${t.due}`);
+    if (t.priority === "high")
+        flags.push("важно");
+    if (t.priority === "low")
+        flags.push("не срочно");
+    if (t.tags.length)
+        flags.push(t.tags.join(", "));
+    return `${t.id} (${t.created})${flags.length ? ` [${flags.join("; ")}]` : ""}: ${t.text}`;
+}
+/** Сколько дней захваченная на панели мысль видна из других проектов. */
+const CAPTURE_WINDOW_DAYS = 7;
+/**
+ * Свежие захваты с панели в соседних проектах.
+ *
+ * Мысль записывают там, где она пришла в голову, а работают потом в другом
+ * проекте — и она лежит незамеченной до следующего открытия того репозитория.
+ * Поэтому только что захваченное (источник panel) видно из любого брифа, но
+ * узким окном и списком: это напоминание разобрать, а не вторая память.
+ */
+function capturedElsewhere(store) {
+    const cutoff = Date.now() - CAPTURE_WINDOW_DAYS * 86_400_000;
+    const lines = [];
+    for (const e of knownProjects()) {
+        if (e.key === store.project.key)
+            continue;
+        try {
+            const other = new Store(resolveProject(e.root));
+            for (const t of sortTasks(other.openTasks())) {
+                // Просроченное показываем независимо от возраста: срок важнее даты захвата.
+                const overdue = Boolean(t.due) && t.due < today();
+                if (t.source !== "panel" || (Date.parse(t.created) < cutoff && !overdue))
+                    continue;
+                lines.push(`- ${e.name} ${taskLine(t)}`);
+            }
+        }
+        catch {
+            // Соседний проект мог уехать или быть недоступен — не повод ломать бриф.
+        }
+    }
+    if (!lines.length)
+        return null;
+    const shown = lines.slice(0, 8);
+    if (lines.length > shown.length)
+        shown.push(`- … ещё ${lines.length - shown.length}`);
+    return `## Захвачено с панели в других проектах (за ${CAPTURE_WINDOW_DAYS} дней)\n${shown.join("\n")}`;
+}
+function gitHint(store) {
+    const git = gitState(store.project.root);
+    return git.available ? `Git: ветка ${git.branch}, HEAD ${git.head}.` : "";
+}
+/** Первый содержательный абзац сессии — обычно раздел «Итог». */
+export function tldr(s, max = 600) {
+    const body = s.body.replace(/^#+\s*Итог\s*\n/m, "");
+    const para = body.split(/\n\s*\n/).find((p) => p.trim() && !p.trim().startsWith("#")) ?? "";
+    return clip(para.trim(), max);
+}
+function defaultFacts(facts) {
+    // Правила и уроки — всегда: их нарушение стоит дороже, чем лишние строки в брифе.
+    const priority = facts.filter((f) => f.type === "rule" || f.type === "lesson");
+    const rest = facts.filter((f) => f.type !== "rule" && f.type !== "lesson").slice(-15).reverse();
+    return [...priority, ...rest];
+}
+function rankedFacts(store, index, topic, facts) {
+    const hits = index.search(topic, { kind: "fact", limit: 15, activeOnly: true });
+    const byId = new Map(facts.map((f) => [f.id, f]));
+    const ranked = hits.map((h) => byId.get(h.id)).filter((f) => Boolean(f));
+    const rules = facts.filter((f) => f.type === "rule" && !ranked.includes(f));
+    return [...ranked, ...rules];
+}
+export function formatFact(f) {
+    const tags = f.tags.length ? ` [${f.tags.join(", ")}]` : "";
+    return `- ${f.id} ${f.type}${tags}: ${f.text.replace(/\s+/g, " ")}`;
+}
+export function clip(text, max) {
+    if (text.length <= max)
+        return text;
+    const cut = text.slice(0, max);
+    const at = Math.max(cut.lastIndexOf("\n"), cut.lastIndexOf(". "));
+    return (at > max * 0.6 ? cut.slice(0, at + 1) : cut).trimEnd() + " …";
+}
+/** Режет разделы с конца (менее важные), пока не влезет в бюджет; заголовок не трогает. */
+function fit(parts, budget) {
+    let total = parts.reduce((n, p) => n + p.length + 2, 0);
+    for (let i = parts.length - 2; i > 0 && total > budget; i--) {
+        const over = total - budget;
+        const keep = Math.max(200, parts[i].length - over);
+        if (keep < parts[i].length) {
+            parts[i] = clip(parts[i], keep);
+            total = parts.reduce((n, p) => n + p.length + 2, 0);
+        }
+    }
+    return parts.join("\n\n");
+}

package/dist/cli.js

@@ -0,0 +1,229 @@
+#!/usr/bin/env node
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { execFileSync } from "node:child_process";
+import { buildBrief } from "./brief.js";
+import { doctor } from "./doctor.js";
+import { SearchIndex } from "./index.js";
+import { applyImport, planImport } from "./importer.js";
+import { resolveProject } from "./paths.js";
+import { saveSession } from "./save.js";
+import { serve } from "./server.js";
+import { knownProjects, touchRegistry } from "./registry.js";
+import { Store } from "./store.js";
+import { extract, guessTranscript, renderSnapshot } from "./transcript.js";
+import { startUi, uiAddress } from "./ui.js";
+import { hostedAddress, startHosted } from "./hosted.js";
+const USAGE = `monisess — память проекта для Claude Code
+
+  monisess                         запустить MCP-сервер (stdio)
+  monisess brief [--topic T]       напечатать бриф проекта
+  monisess hook session-start      хук SessionStart: бриф в контекст, после сжатия — снимок
+  monisess hook pre-compact        хук PreCompact: автоснимок сессии до сжатия
+  monisess install                 подключить MCP-сервер и хуки в Claude Code (уровень пользователя)
+  monisess import [MD_HISTORY] [--apply]   перенести контексты dedsession
+  monisess doctor [--fix]          проверка памяти
+  monisess projects                проекты с памятью на этой машине
+  monisess ui [--port 4620]        локальная панель в браузере
+  monisess hosted                  сервер monisess.com (нужны GITHUB_CLIENT_ID/SECRET, SESSION_SECRET)
+`;
+/** Правила поведения едут вместе с брифом: коротко и один раз за сессию. */
+const PREAMBLE = "Monisess: память проекта подключена (инструменты brief/save/recall/fact/task/note). " +
+    "Закончил задачу или человек сказал «сохрани» — вызови save с итогом, решениями, проблемами и списком «осталось». " +
+    "Новое долговременное знание — fact; устаревший факт заменяй новым через supersedes; мысль на бегу — note.";
+async function main(argv) {
+    const [cmd, ...rest] = argv;
+    const flag = (name) => {
+        const i = rest.indexOf(`--${name}`);
+        return i >= 0 ? rest[i + 1] : undefined;
+    };
+    const has = (name) => rest.includes(`--${name}`);
+    switch (cmd) {
+        case undefined:
+        case "serve":
+            // Сервер живёт, пока Claude Code держит stdio: выходить после connect нельзя.
+            await serve();
+            return null;
+        case "brief": {
+            const store = new Store(resolveProject());
+            const index = new SearchIndex(store);
+            process.stdout.write(buildBrief(store, index, { topic: flag("topic") }) + "\n");
+            return 0;
+        }
+        case "hook":
+            return hook(rest[0] ?? "");
+        case "install":
+            return install();
+        case "import": {
+            const project = resolveProject();
+            const store = new Store(project);
+            const dir = path.resolve(project.root, rest.find((a) => !a.startsWith("--")) ?? "MD_HISTORY");
+            const plans = planImport(dir);
+            if (!has("apply")) {
+                console.log(`К импорту ${plans.length} контекстов из ${dir} (добавьте --apply):`);
+                for (const p of plans)
+                    console.log(`  ${p.date} ${p.title}`);
+                return 0;
+            }
+            const ids = applyImport(store, plans);
+            console.log(`Импортировано сессий: ${ids.length}`);
+            return 0;
+        }
+        case "ui": {
+            // Панель показывает проекты из реестра: текущий (если у него есть память) отмечаем сами,
+            // чтобы её не приходилось «прогревать» отдельной сессией Claude.
+            touchRegistry(resolveProject());
+            const server = await startUi(Number(flag("port") ?? 4620));
+            console.log(`Панель monisess: ${uiAddress(server)} (Ctrl+C — выход)`);
+            return null;
+        }
+        case "hosted": {
+            const server = await startHosted();
+            console.log(`Хостовый режим: ${hostedAddress(server)} (за Caddy)`);
+            return null;
+        }
+        case "projects": {
+            for (const e of knownProjects())
+                console.log(`${e.name}\t${e.root}\t${e.lastSeen}`);
+            return 0;
+        }
+        case "doctor": {
+            const store = new Store(resolveProject());
+            console.log(doctor(store, new SearchIndex(store), has("fix")));
+            return 0;
+        }
+        default:
+            process.stderr.write(USAGE);
+            return cmd === "help" || cmd === "--help" ? 0 : 2;
+    }
+}
+function readStdinJson() {
+    try {
+        const raw = fs.readFileSync(0, "utf8");
+        return raw.trim() ? JSON.parse(raw) : {};
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Хуки не должны ломать сессию: любая ошибка внутри — молча в stderr и код 0.
+ * Автоснимки делаются только там, где память уже заведена: создавать .monisess/
+ * в каждом репозитории, куда заглянул Claude, было бы навязчиво.
+ */
+function hook(event) {
+    const payload = readStdinJson();
+    const project = resolveProject(payload.cwd || process.cwd());
+    const store = new Store(project);
+    try {
+        if (event === "session-start") {
+            if (payload.source === "compact") {
+                const made = snapshot(store, payload, "compact");
+                if (made)
+                    process.stdout.write(`Monisess: автоснимок сессии сохранён (${made}).\n`);
+                return 0;
+            }
+            // Без заведённой памяти молчим: хук стоит на всех проектах, а шуметь в чужих не надо.
+            if (!store.exists())
+                return 0;
+            touchRegistry(project);
+            const index = new SearchIndex(store);
+            const brief = buildBrief(store, index, {});
+            process.stdout.write(`${PREAMBLE}\n\n${brief}\n`);
+            return 0;
+        }
+        if (event === "pre-compact") {
+            snapshot(store, payload, "pre-compact");
+            return 0;
+        }
+        process.stderr.write(`monisess hook: неизвестное событие «${event}»\n`);
+        return 0;
+    }
+    catch (err) {
+        process.stderr.write(`monisess hook: ${err.message}\n`);
+        return 0;
+    }
+}
+function snapshot(store, payload, phase) {
+    if (!store.exists())
+        return null;
+    const transcript = payload.transcript_path || guessTranscript(store.project.root);
+    if (!transcript)
+        return null;
+    const index = new SearchIndex(store);
+    const stateKey = `transcript:${transcript}`;
+    const e = extract(transcript, index.getState(stateKey));
+    if (!e.lastUuid)
+        return null;
+    const rendered = renderSnapshot(e, store.project.root);
+    const last = store.lastSession();
+    const recentAuto = last && last.kind === "auto" && Date.now() - Date.parse(last.date.replace(" ", "T")) < 20 * 60_000;
+    let id = null;
+    if (phase === "compact" && e.compactSummary && recentAuto && last) {
+        // Снимок до сжатия уже есть — дописываем к нему сводку, а не плодим вторую запись.
+        const current = fs.readFileSync(last.file, "utf8").replace(/\s+$/, "");
+        fs.writeFileSync(last.file, `${current}\n\n## Сводка сжатия контекста\n${e.compactSummary.slice(0, 12_000)}\n`, "utf8");
+        id = last.id;
+    }
+    else if (e.compactSummary || e.prompts.length || e.files.length) {
+        id = saveSession(store, { ...rendered, kind: "auto" }).session.id;
+    }
+    index.setState(stateKey, e.lastUuid);
+    return id;
+}
+/** Регистрирует сервер и хуки на уровне пользователя; повторный запуск ничего не дублирует. */
+function install() {
+    let bin = process.argv[1];
+    // Через `npx monisess install` пакет лежит во временном кэше, который npm чистит сам —
+    // путь оттуда в настройках однажды перестанет работать. Ставим тот же выпуск глобально.
+    if (bin.includes(`${path.sep}_npx${path.sep}`)) {
+        const pkg = path.join(path.dirname(fs.realpathSync(bin)), "..", "package.json");
+        const { version } = JSON.parse(fs.readFileSync(pkg, "utf8"));
+        execFileSync("npm", ["install", "--global", `monisess@${version}`], { stdio: "inherit" });
+        bin = path.join(execFileSync("npm", ["root", "--global"], { encoding: "utf8" }).trim(), "monisess", "dist", "cli.js");
+    }
+    const command = fs.existsSync(bin) && path.basename(bin) === "cli.js" ? `node "${bin}"` : "monisess";
+    const settingsPath = path.join(os.homedir(), ".claude", "settings.json");
+    let settings = {};
+    try {
+        settings = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+    }
+    catch {
+        // файла ещё нет — создадим
+    }
+    const hooks = (settings.hooks ??= {});
+    const ensure = (event, cmd) => {
+        const list = (hooks[event] ??= []);
+        const present = list.some((entry) => entry.hooks?.some((h) => h.command.includes("monisess hook") || h.command.includes(`${command} hook`)));
+        if (!present)
+            list.push({ matcher: "", hooks: [{ type: "command", command: cmd }] });
+        return !present;
+    };
+    const added = [ensure("SessionStart", `${command} hook session-start`), ensure("PreCompact", `${command} hook pre-compact`)];
+    fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    console.log(`Хуки в ${settingsPath}: ${added.filter(Boolean).length ? "добавлены" : "уже были"}`);
+    try {
+        execFileSync("claude", ["mcp", "get", "monisess"], { stdio: "ignore" });
+        console.log("MCP-сервер monisess уже подключён");
+    }
+    catch {
+        try {
+            const args = ["mcp", "add", "--scope", "user", "monisess", "--", ...(command === "monisess" ? ["monisess"] : ["node", bin])];
+            execFileSync("claude", args, { stdio: "inherit" });
+        }
+        catch {
+            console.log(`Не удалось вызвать claude CLI. Подключите вручную:\n  claude mcp add --scope user monisess -- ${command}`);
+        }
+    }
+    console.log("Готово. Новая сессия Claude Code получит бриф автоматически.");
+    return 0;
+}
+main(process.argv.slice(2)).then((code) => {
+    if (code !== null)
+        process.exit(code);
+}, (err) => {
+    process.stderr.write(`monisess: ${err.stack ?? err}\n`);
+    process.exit(1);
+});

package/dist/doctor.js

@@ -0,0 +1,77 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { parse, str } from "./frontmatter.js";
+import { commitExists, commitsSince, gitState } from "./git.js";
+import { readText } from "./paths.js";
+/** Отчёт о состоянии памяти. Чинит только производное (индекс); записи человека не трогает. */
+export function doctor(store, index, fix) {
+    const lines = [`# Monisess doctor — ${store.project.name}`, `папка: ${store.dir}`, `кеш: ${store.project.cache}`];
+    if (!store.exists()) {
+        lines.push("Память не создана (первый save создаст).");
+        if (fs.existsSync(path.join(store.project.root, "MD_HISTORY")))
+            lines.push("Есть MD_HISTORY от dedsession — можно импортировать: import_md_history.");
+        return lines.join("\n");
+    }
+    const problems = [];
+    let ok = 0;
+    for (const sub of ["facts", "tasks", "sessions"]) {
+        const dir = path.join(store.dir, sub);
+        if (!fs.existsSync(dir))
+            continue;
+        for (const f of fs.readdirSync(dir)) {
+            if (!f.endsWith(".md"))
+                continue;
+            const doc = parse(readText(path.join(dir, f)) ?? "");
+            if (!str(doc.meta, "id"))
+                problems.push(`${sub}/${f}: нет id во фронтматтере`);
+            else if (!f.startsWith(str(doc.meta, "id")))
+                problems.push(`${sub}/${f}: имя файла не совпадает с id ${str(doc.meta, "id")}`);
+            else
+                ok += 1;
+        }
+    }
+    lines.push(`записей: ${ok}${problems.length ? `, с проблемами: ${problems.length}` : ""}`);
+    lines.push(...problems.map((p) => `  ✗ ${p}`));
+    const facts = store.facts();
+    const ids = new Set(facts.map((f) => f.id));
+    const dupes = facts.map((f) => f.id).filter((id, i, arr) => arr.indexOf(id) !== i);
+    if (dupes.length)
+        lines.push(`✗ дубли id фактов: ${[...new Set(dupes)].join(", ")}`);
+    for (const f of facts) {
+        if (f.supersedes && !ids.has(f.supersedes))
+            lines.push(`✗ ${f.id} ссылается на несуществующий ${f.supersedes}`);
+        if (f.status === "active" && facts.some((g) => g.supersedes === f.id && g.status === "active")) {
+            lines.push(`✗ ${f.id} активен, хотя заменён другим активным фактом`);
+        }
+    }
+    const rebuilt = index.sync(fix);
+    lines.push(`индекс: ${index.count()} документов${rebuilt ? " (пересобран)" : ""}`);
+    const git = gitState(store.project.root);
+    if (git.available) {
+        const dirtyMem = git.dirty.filter((l) => l.includes(".monisess/")).length;
+        if (dirtyMem)
+            lines.push(`⚠ в .monisess/ незакоммиченных изменений: ${dirtyMem} — память не уедет на другие машины`);
+        const last = store.lastSession();
+        if (last?.head) {
+            if (!commitExists(store.project.root, last.head))
+                lines.push(`⚠ HEAD последней сессии ${last.head} не найден в истории`);
+            else {
+                const n = commitsSince(store.project.root, last.head, 200)?.length ?? 0;
+                if (n > 5)
+                    lines.push(`⚠ с последней сессии ${n} коммитов без сохранённого контекста`);
+            }
+        }
+    }
+    const open = store.openTasks();
+    const stale = open.filter((t) => Date.now() - Date.parse(t.created) > 60 * 86_400_000);
+    if (stale.length)
+        lines.push(`⚠ задач старше 60 дней: ${stale.map((t) => t.id).join(", ")} — закрыть или подтвердить`);
+    if (fs.existsSync(path.join(store.project.root, "MD_HISTORY"))) {
+        const imported = store.sessions().filter((s) => s.kind === "imported").length;
+        if (!imported)
+            lines.push("Есть MD_HISTORY от dedsession, ещё не импортирована: import_md_history.");
+    }
+    if (!problems.length && !dupes.length)
+        lines.push("✓ записи целы");
+    return lines.join("\n");
+}