@moabpro/recap-mcp 0.1.0

package/README.md

@@ -0,0 +1,26 @@
+# @moabpro/recap-mcp
+
+MCP-сервер **MoabRecap** для Claude Code: команды `/moabrecap` и `/switch-project`. Авторизация — через портал (Keycloak device-flow), доступ строго по роли **crew**.
+
+## Установка
+1. Пропиши MCP-сервер и SessionStart-хук в конфиг Claude Code:
+   ```bash
+   npx -y @moabpro/recap-mcp init
+   ```
+2. Перезапусти Claude Code.
+3. Выполни инструмент **`login`** (device-flow) — откроется ссылка авторизации на auth.moab.tools; подтверди под учёткой с портальной ролью **crew**.
+
+## Использование
+- `/switch-project` — выбрать/сменить проект, закреплённый за сессией.
+- `/moabrecap` — сделать recap за период с прошлого рекапа.
+- `login` / `auth_status` / `auth_logout` — управление входом.
+
+## Обновление
+`npx` тянет свежую версию автоматически — отдельных действий не нужно.
+
+## Конфигурация (опц., env)
+- `RECAP_URL` (по умолчанию `https://recap.moab.tools`)
+- `KEYCLOAK_AUTHORITY` (по умолчанию `https://auth.moab.tools/realms/moab`)
+- `KEYCLOAK_CLIENT` (по умолчанию `share-cli`)
+
+Лицензия: UNLICENSED (внутренний инструмент moab.tools).

package/dist/api-client.js

@@ -0,0 +1,33 @@
+import { ApiError } from './errors.js';
+export class RecapApi {
+    cfg;
+    auth;
+    constructor(cfg, auth) {
+        this.cfg = cfg;
+        this.auth = auth;
+    }
+    async authed(path, init) {
+        const token = await this.auth.getAccessToken();
+        const withAuth = (t) => ({ ...init, headers: { ...init.headers, Authorization: `Bearer ${t}` } });
+        let res = await fetch(this.cfg.apiBase + path, withAuth(token));
+        if (res.status === 401) {
+            const fresh = await this.auth.invalidateAndRefresh();
+            res = await fetch(this.cfg.apiBase + path, withAuth(fresh));
+        }
+        return res;
+    }
+    async postRecap(body) {
+        const r = await this.authed('/api/recaps', {
+            method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body),
+        });
+        if (!r.ok)
+            throw new ApiError(r.status, await r.text());
+        return (await r.json());
+    }
+    async myProjects() {
+        const r = await this.authed('/api/recaps/my-projects', { method: 'GET', headers: {} });
+        if (!r.ok)
+            throw new ApiError(r.status, await r.text());
+        return (await r.json());
+    }
+}

package/dist/auth-errors.js

@@ -0,0 +1,8 @@
+/** Нет валидного токена — нужно запустить login. */
+export class AuthRequiredError extends Error {
+    constructor(message) { super(message); this.name = 'AuthRequiredError'; }
+}
+/** Device flow стартован, но вход ещё не подтверждён в браузере. */
+export class AuthPendingError extends Error {
+    constructor(message) { super(message); this.name = 'AuthPendingError'; }
+}

package/dist/auth.js

@@ -0,0 +1,129 @@
+import { mkdir, readFile, writeFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { AuthRequiredError, AuthPendingError } from './auth-errors.js';
+/** Хранит AuthState в <dir>/credentials.json. На Windows POSIX-mode (0600/0700) — no-op; защита = ACL профиля. */
+export class FileTokenStore {
+    dir;
+    file;
+    constructor(dir) {
+        this.dir = dir;
+        this.file = join(dir, 'credentials.json');
+    }
+    async load() {
+        try {
+            return JSON.parse(await readFile(this.file, 'utf8'));
+        }
+        catch (e) {
+            if (e.code === 'ENOENT')
+                return null;
+            throw e;
+        }
+    }
+    async save(state) {
+        await mkdir(this.dir, { recursive: true, mode: 0o700 });
+        await writeFile(this.file, JSON.stringify(state, null, 2), { mode: 0o600 });
+    }
+    async clear() { await rm(this.file, { force: true }); }
+}
+const EXPIRY_SKEW_MS = 30_000;
+const DEVICE_GRANT = 'urn:ietf:params:oauth:grant-type:device_code';
+export class Authenticator {
+    cfg;
+    store;
+    fetchFn;
+    now;
+    constructor(cfg, store, fetchFn = fetch, now = () => Date.now()) {
+        this.cfg = cfg;
+        this.store = store;
+        this.fetchFn = fetchFn;
+        this.now = now;
+    }
+    deviceUrl() { return `${this.cfg.authority}/protocol/openid-connect/auth/device`; }
+    tokenUrl() { return `${this.cfg.authority}/protocol/openid-connect/token`; }
+    async startLogin() {
+        const res = await this.fetchFn(this.deviceUrl(), {
+            method: 'POST',
+            headers: { 'content-type': 'application/x-www-form-urlencoded' },
+            body: new URLSearchParams({ client_id: this.cfg.client, scope: 'openid offline_access' }),
+        });
+        if (!res.ok)
+            throw new Error(`device flow start failed: ${res.status}`);
+        const dc = (await res.json());
+        await this.store.save({ pending: { deviceCode: dc.device_code, interval: dc.interval, deadline: this.now() + dc.expires_in * 1000 } });
+        return dc;
+    }
+    async getAccessToken() {
+        const state = await this.store.load();
+        if (!state)
+            throw new AuthRequiredError('Не авторизовано. Запустите инструмент login.');
+        if (state.tokens && state.tokens.expiresAt - this.now() > EXPIRY_SKEW_MS)
+            return state.tokens.accessToken;
+        if (state.tokens)
+            return this.refreshOrThrow(state.tokens.refreshToken);
+        if (state.pending)
+            return this.completePendingOrThrow(state.pending);
+        throw new AuthRequiredError('Не авторизовано. Запустите инструмент login.');
+    }
+    async invalidateAndRefresh() {
+        const state = await this.store.load();
+        if (!state?.tokens)
+            throw new AuthRequiredError('Не авторизовано. Запустите инструмент login.');
+        return this.refreshOrThrow(state.tokens.refreshToken);
+    }
+    async status() {
+        const state = await this.store.load();
+        if (!state?.tokens)
+            return { loggedIn: false };
+        const username = decodeUsername(state.tokens.accessToken);
+        return username ? { loggedIn: true, username } : { loggedIn: true };
+    }
+    async logout() { await this.store.clear(); }
+    async refreshOrThrow(refreshToken) {
+        const res = await this.fetchFn(this.tokenUrl(), {
+            method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' },
+            body: new URLSearchParams({ grant_type: 'refresh_token', refresh_token: refreshToken, client_id: this.cfg.client }),
+        });
+        if (!res.ok) {
+            await this.store.clear();
+            throw new AuthRequiredError('Сессия истекла. Запустите инструмент login заново.');
+        }
+        const b = (await res.json());
+        const tokens = { accessToken: b.access_token, refreshToken: b.refresh_token, expiresAt: this.now() + b.expires_in * 1000 };
+        await this.store.save({ tokens });
+        return tokens.accessToken;
+    }
+    async completePendingOrThrow(pending) {
+        if (this.now() > pending.deadline) {
+            await this.store.clear();
+            throw new AuthRequiredError('Код подтверждения истёк. Запустите login заново.');
+        }
+        const res = await this.fetchFn(this.tokenUrl(), {
+            method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' },
+            body: new URLSearchParams({ grant_type: DEVICE_GRANT, device_code: pending.deviceCode, client_id: this.cfg.client }),
+        });
+        if (res.ok) {
+            const b = (await res.json());
+            const tokens = { accessToken: b.access_token, refreshToken: b.refresh_token, expiresAt: this.now() + b.expires_in * 1000 };
+            await this.store.save({ tokens });
+            return tokens.accessToken;
+        }
+        const err = (await res.json().catch(() => ({})));
+        if (err.error === 'authorization_pending' || err.error === 'slow_down')
+            throw new AuthPendingError('Вход ещё не подтверждён. Подтвердите в браузере и повторите запрос.');
+        await this.store.clear();
+        throw new AuthRequiredError('Не удалось войти. Запустите инструмент login заново.');
+    }
+}
+/** preferred_username/email из payload JWT (без верификации — только для отображения). */
+function decodeUsername(jwt) {
+    const parts = jwt.split('.');
+    if (parts.length < 2)
+        return undefined;
+    try {
+        const p = JSON.parse(Buffer.from(parts[1], 'base64url').toString('utf8'));
+        return p.preferred_username ?? p.email ?? undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/config.js

@@ -0,0 +1,16 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export function loadConfig(env = process.env) {
+    const base = (env.RECAP_URL ?? '').replace(/\/+$/, '');
+    const rootDir = env.MOAB_CONFIG_DIR ?? join(homedir(), '.moab');
+    return {
+        apiBase: base,
+        authority: env.KEYCLOAK_AUTHORITY ?? 'https://auth.moab.tools/realms/moab',
+        client: env.KEYCLOAK_CLIENT ?? 'share-cli',
+        configDir: join(rootDir, 'recap-mcp'),
+        userEmail: env.RECAP_USER_EMAIL,
+        userName: env.RECAP_USER_NAME,
+        stateDir: homedir(),
+        claudeDir: join(homedir(), '.claude'),
+    };
+}

package/dist/errors.js

@@ -0,0 +1,20 @@
+export class ApiError extends Error {
+    status;
+    bodyText;
+    constructor(status, bodyText) {
+        super(`API ${status}`);
+        this.status = status;
+        this.bodyText = bodyText;
+    }
+}
+/** Дружелюбный русский текст по HTTP-коду ответа /api/recaps. */
+export function ruRecapError(status, body) {
+    switch (status) {
+        case 401: return '✗ Вход не принят или истёк. Выполни инструмент login (device-flow) и повтори.';
+        case 403: return '✗ Доступ запрещён: нужна портальная роль crew. Обратись к администратору портала.';
+        case 409: return '⚠ Сервер счёл recap дубликатом (409). Если ты не отправлял его только что повторно — возможно ушло пустое тело; проверь дашборд. Памятка НЕ обновлена.';
+        case 429: return '✗ Rate limit превышен, попробуй позже.';
+        case 400: return `✗ Сервер отверг recap (400): ${body.slice(0, 300)}`;
+        default: return `✗ Recap не доставлен (HTTP ${status}): ${body.slice(0, 300)}`;
+    }
+}

package/dist/git.js

@@ -0,0 +1,50 @@
+import { execFileSync } from 'node:child_process';
+/** Парсер shortstat-лога: commits = строки с хешем; суммы из "N files changed, …". */
+export function parseGitStats(log) {
+    let commitsCount = 0, filesChanged = 0, linesAdded = 0, linesRemoved = 0;
+    for (const line of log.split('\n')) {
+        if (/^[0-9a-f]{7,40}\s/.test(line))
+            commitsCount++;
+        let m;
+        if ((m = line.match(/(\d+) files? changed/)))
+            filesChanged += Number(m[1]);
+        if ((m = line.match(/(\d+) insertions?\(\+\)/)))
+            linesAdded += Number(m[1]);
+        if ((m = line.match(/(\d+) deletions?\(-\)/)))
+            linesRemoved += Number(m[1]);
+    }
+    return { commitsCount, filesChanged, linesAdded, linesRemoved };
+}
+function git(cwd, args) {
+    return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+}
+/** Собрать git-статистику окна. since — ISO или "12 hours ago"; authorEmail для фильтра log. */
+export function collectGit(cwd, since, authorEmail) {
+    let isRepo = true;
+    try {
+        git(cwd, ['rev-parse', '--is-inside-work-tree']);
+    }
+    catch {
+        isRepo = false;
+    }
+    if (!isRepo) {
+        return { isRepo: false, raw: null, commitsCount: 0, filesChanged: 0, linesAdded: 0, linesRemoved: 0 };
+    }
+    let diffStat = '', log = '';
+    try {
+        diffStat = git(cwd, ['diff', '--stat', 'HEAD']);
+    }
+    catch { /* пусто */ }
+    const logArgs = ['log', `--since=${since}`, '--no-merges', '--shortstat', '--pretty=tformat:%h %s'];
+    if (authorEmail)
+        logArgs.push(`--author=${authorEmail}`); // пустой author → без фильтра (иначе git матчит ВСЕ коммиты); окно ограничено --since
+    try {
+        log = git(cwd, logArgs);
+    }
+    catch { /* пусто */ }
+    const stats = parseGitStats(log);
+    let raw = `${diffStat}\n${log}`.trim() || null;
+    if (raw && raw.length > 4800)
+        raw = raw.slice(0, 4800) + '\n…(обрезано)';
+    return { isRepo: true, raw, ...stats };
+}

package/dist/index.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { loadConfig } from './config.js';
+import { createServer } from './server.js';
+import { runInit } from './init.js';
+import { runSessionStart } from './session-start.js';
+async function main() {
+    const sub = process.argv[2];
+    if (sub === 'init') {
+        await runInit();
+        return;
+    }
+    if (sub === 'session-start') {
+        await runSessionStart();
+        return;
+    }
+    const server = createServer({ config: loadConfig() });
+    await server.connect(new StdioServerTransport());
+}
+main().catch((e) => {
+    // stdout зарезервирован под MCP-протокол — диагностика только в stderr.
+    console.error('moab-recap fatal:', e);
+    process.exit(1);
+});

package/dist/init.js

@@ -0,0 +1,60 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+function readJson(file) {
+    if (!existsSync(file))
+        return {};
+    try {
+        return JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * `recap-mcp init`: прописать MCP-сервер (~/.claude.json) и SessionStart-хук (~/.claude/settings.json).
+ * Идемпотентно. Перед перезаписью ~/.claude.json делает бэкап (критичный файл, управляется Claude Code).
+ */
+export async function runInit() {
+    const home = homedir();
+    const claudeJson = join(home, '.claude.json'); // user-scope MCP servers — ЗДЕСЬ
+    const settingsJson = join(home, '.claude', 'settings.json'); // hooks — ЗДЕСЬ
+    mkdirSync(join(home, '.claude'), { recursive: true });
+    // 1) MCP-сервер в ~/.claude.json (type:stdio; литеральные дефолты — без ${...}-интерполяции)
+    const cj = readJson(claudeJson);
+    if (existsSync(claudeJson)) {
+        try {
+            copyFileSync(claudeJson, claudeJson + '.recap-bak');
+        }
+        catch { /* бэкап best-effort */ }
+    }
+    cj.mcpServers ??= {};
+    cj.mcpServers['moab-recap'] = {
+        type: 'stdio',
+        command: 'npx',
+        args: ['-y', '@moabpro/recap-mcp'],
+        env: {
+            RECAP_URL: 'https://recap.moab.tools',
+            KEYCLOAK_AUTHORITY: 'https://auth.moab.tools/realms/moab',
+            KEYCLOAK_CLIENT: 'share-cli',
+        },
+    };
+    writeFileSync(claudeJson, JSON.stringify(cj, null, 2));
+    // 2) SessionStart-хук в ~/.claude/settings.json (command → npx recap-mcp session-start)
+    const sj = readJson(settingsJson);
+    sj.hooks ??= {};
+    sj.hooks.SessionStart ??= [];
+    const already = JSON.stringify(sj.hooks.SessionStart).includes('recap-mcp');
+    if (!already) {
+        sj.hooks.SessionStart.push({
+            matcher: '*',
+            hooks: [{ type: 'command', command: 'npx -y @moabpro/recap-mcp session-start', timeout: 15 }],
+        });
+    }
+    writeFileSync(settingsJson, JSON.stringify(sj, null, 2));
+    process.stdout.write('✓ recap-mcp прописан:\n' +
+        `  • MCP-сервер       → ${claudeJson} (mcpServers.moab-recap, type=stdio)\n` +
+        `  • SessionStart хук → ${settingsJson} (hooks.SessionStart)\n` +
+        'После перезапуска Claude Code выполните инструмент login (device-flow) — нужна портальная роль crew.\n' +
+        'Перезапусти Claude Code.\n');
+}

package/dist/meta.js

@@ -0,0 +1,58 @@
+import { hostname } from 'node:os';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { sessionsDir } from './paths.js';
+function gitConfig(cwd, key) {
+    try {
+        return execFileSync('git', ['config', key], { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Текущий session_id: env CLAUDE_RECAP_SESSION_ID, иначе имя свежайшего session-state-файла. */
+export function currentSessionId(env = process.env) {
+    if (env.CLAUDE_RECAP_SESSION_ID)
+        return env.CLAUDE_RECAP_SESSION_ID;
+    const dir = sessionsDir();
+    if (!existsSync(dir))
+        return null;
+    let best = null;
+    for (const f of readdirSync(dir)) {
+        if (!f.endsWith('.json'))
+            continue;
+        try {
+            const m = statSync(join(dir, f)).mtimeMs;
+            if (!best || m > best.m)
+                best = { id: basename(f, '.json'), m };
+        }
+        catch { /* skip */ }
+    }
+    return best?.id ?? null;
+}
+/** Закреплённый проект сессии (project=null + research_mode при research). */
+export function readSessionState(sid) {
+    if (!sid)
+        return { project: null, research_mode: false };
+    const file = join(sessionsDir(), `${sid}.json`);
+    if (!existsSync(file))
+        return { project: null, research_mode: false };
+    try {
+        const d = JSON.parse(readFileSync(file, 'utf8'));
+        return { project: d.project ?? null, research_mode: !!d.research_mode };
+    }
+    catch {
+        return { project: null, research_mode: false };
+    }
+}
+export function collectMeta(cfg, cwd) {
+    return {
+        userEmail: cfg.userEmail ?? gitConfig(cwd, 'user.email') ?? 'unknown',
+        userName: cfg.userName ?? gitConfig(cwd, 'user.name') ?? cfg.userEmail ?? 'unknown',
+        projectPath: cwd,
+        clientHost: hostname(),
+        gitRemoteUrl: gitConfig(cwd, 'remote.origin.url'),
+        clientTimestamp: new Date().toISOString(),
+    };
+}

package/dist/paths.js

@@ -0,0 +1,17 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/** Стабильный ключ пути для памятки: lowercase, forward slashes, /c/x → c:/x, без хвостовых /. */
+export function normalizeCwdKey(p) {
+    let s = p.replace(/\\/g, '/').toLowerCase();
+    // /c/proj → c:/proj
+    const m = s.match(/^\/([a-z])\/(.*)$/);
+    if (m)
+        s = `${m[1]}:/${m[2]}`;
+    s = s.replace(/\/+$/, '');
+    return s;
+}
+export const lastRecapFile = () => join(homedir(), '.claude-recap-last.json');
+export const sessionsDir = () => join(homedir(), '.claude-recap-sessions');
+export const projectsDir = () => join(homedir(), '.claude', 'projects');
+/** Корень проекта: Claude Code выставляет CLAUDE_PROJECT_DIR в env MCP-сервера; иначе текущий cwd. */
+export const projectDir = () => process.env.CLAUDE_PROJECT_DIR || process.cwd();

package/dist/prompts/index.js

@@ -0,0 +1,6 @@
+import { registerMoabrecapPrompt } from './moabrecap.js';
+import { registerSwitchProjectPrompt } from './switch-project.js';
+export function registerPrompts(server) {
+    registerMoabrecapPrompt(server);
+    registerSwitchProjectPrompt(server);
+}

package/dist/prompts/moabrecap.js

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+const RULES = `Сделай recap текущей работы и отправь его инструментом send_recap.
+
+ОКНО: описывай только то, что сделано С МОМЕНТА ПРОШЛОГО РЕКАПА (инструмент сам посчитает окно
+по git и времени; ты отрази в summary суть именно этого периода — поможет git log/diff и контекст).
+
+SUMMARY (поле summary) — для РУКОВОДИТЕЛЯ, НЕ для разработчика:
+- 3-5 предложений по-русски, жёсткий потолок 1800 символов.
+- Простым языком, БЕЗ техники: не «refactor/bundle/endpoint/Mongo/.NET/имена файлов», а бизнес-результат
+  («сделали так, что у каждого свой ключ доступа», «дашборд теперь грузится в портал»).
+- ОБЯЗАТЕЛЬНО в конце 1-2 предложения про «обратную сторону»: что НЕ успели, где застряли, какой
+  долг вскрылся. Если реально всё гладко — одно предложение «Открытых хвостов в этом окне нет.»
+
+TAGS (1-3 из): feature, bugfix, refactor, docs, tests, setup, infra, research, review, planning, other.
+COMPLEXITY (1-5): 1=опечатка/2=мелкий CRUD/3=многокомпонентная фича или нетривиальный дебаг/4=многофайловый
+рефактор или сложная гонка/5=архитектура.
+EFFORT (1-5): 1<15мин/2~30мин/3=1-2ч/4=полдня/5=день+.
+
+ПРОВЕРКА «маловато»: если complexity ≤ 3 — сначала спроси пользователя через AskUserQuestion
+«Маловато изменений для рекапа. Может, ещё поработаем?» (варианты: «Да, поработаем» / «Нет, сделать рекап
+сейчас»). Если «Да» — НЕ вызывай send_recap, заверши строкой «✓ Ок, продолжаем — recap не отправлен.»
+Если complexity ≥ 4 — пропусти проверку и сразу вызывай send_recap.
+
+Если пользователь дал подсказку-аргумент — учти её и передай как userHint.`;
+export function registerMoabrecapPrompt(server) {
+    server.registerPrompt('moabrecap', {
+        title: 'Сделать moabrecap',
+        description: 'Описать сделанное с прошлого рекапа и отправить через moabrecap (send_recap).',
+        argsSchema: { hint: z.string().optional().describe('Опц. подсказка, о чём был период') },
+    }, ({ hint }) => ({
+        messages: [{
+                role: 'user',
+                content: { type: 'text', text: hint ? `${RULES}\n\nПодсказка пользователя: ${hint}` : RULES },
+            }],
+    }));
+}

package/dist/prompts/recap.js

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+const RULES = `Сделай recap текущей работы и отправь его инструментом send_recap.
+
+ОКНО: описывай только то, что сделано С МОМЕНТА ПРОШЛОГО РЕКАПА (инструмент сам посчитает окно
+по git и времени; ты отрази в summary суть именно этого периода — поможет git log/diff и контекст).
+
+SUMMARY (поле summary) — для РУКОВОДИТЕЛЯ, НЕ для разработчика:
+- 3-5 предложений по-русски, жёсткий потолок 1800 символов.
+- Простым языком, БЕЗ техники: не «refactor/bundle/endpoint/Mongo/.NET/имена файлов», а бизнес-результат
+  («сделали так, что у каждого свой ключ доступа», «дашборд теперь грузится в портал»).
+- ОБЯЗАТЕЛЬНО в конце 1-2 предложения про «обратную сторону»: что НЕ успели, где застряли, какой
+  долг вскрылся. Если реально всё гладко — одно предложение «Открытых хвостов в этом окне нет.»
+
+TAGS (1-3 из): feature, bugfix, refactor, docs, tests, setup, infra, research, review, planning, other.
+COMPLEXITY (1-5): 1=опечатка/2=мелкий CRUD/3=многокомпонентная фича или нетривиальный дебаг/4=многофайловый
+рефактор или сложная гонка/5=архитектура.
+EFFORT (1-5): 1<15мин/2~30мин/3=1-2ч/4=полдня/5=день+.
+
+ПРОВЕРКА «маловато»: если complexity ≤ 3 — сначала спроси пользователя через AskUserQuestion
+«Маловато изменений для рекапа. Может, ещё поработаем?» (варианты: «Да, поработаем» / «Нет, сделать рекап
+сейчас»). Если «Да» — НЕ вызывай send_recap, заверши строкой «✓ Ок, продолжаем — recap не отправлен.»
+Если complexity ≥ 4 — пропусти проверку и сразу вызывай send_recap.
+
+Если пользователь дал подсказку-аргумент — учти её и передай как userHint.`;
+export function registerRecapPrompt(server) {
+    server.registerPrompt('recap', {
+        title: 'Сделать recap',
+        description: 'Описать сделанное с прошлого рекапа и отправить (через send_recap).',
+        argsSchema: { hint: z.string().optional().describe('Опц. подсказка, о чём был период') },
+    }, ({ hint }) => ({
+        messages: [{
+                role: 'user',
+                content: { type: 'text', text: hint ? `${RULES}\n\nПодсказка пользователя: ${hint}` : RULES },
+            }],
+    }));
+}

package/dist/prompts/switch-project.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+const RULES = `Смени проект, закреплённый за этой сессией.
+
+1. Если у текущей сессии уже закреплён проект и это не research — сначала предложи пользователю
+   сделать /moabrecap по текущему проекту (через AskUserQuestion). Если согласен — выполни /moabrecap, потом продолжай.
+2. Если дан аргумент-имя — используй его напрямую как имя проекта. Иначе вызови инструмент list_projects,
+   покажи нумерованный список (плюс «0. Research-сессия без проекта» и «N. Создать новый проект»), жди цифру.
+3. Сопоставь цифру: 0 → pin_project с "__research__"; существующий → pin_project с этим именем;
+   «создать новый» → спроси имя и pin_project с ним.
+4. После закрепления — подтверди и покажи готовую строку «/rename <имя>» (её пользователь скопирует сам;
+   сам /rename вызвать нельзя).`;
+export function registerSwitchProjectPrompt(server) {
+    server.registerPrompt('switch-project', {
+        title: 'Сменить проект сессии',
+        description: 'Выбрать/сменить проект, закреплённый за текущей сессией рекапов.',
+        argsSchema: { name: z.string().optional().describe('Имя проекта (если уже известно)') },
+    }, ({ name }) => ({
+        messages: [{ role: 'user', content: { type: 'text', text: name ? `${RULES}\n\nИмя проекта: ${name}` : RULES } }],
+    }));
+}

package/dist/server.js

@@ -0,0 +1,13 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { RecapApi } from './api-client.js';
+import { FileTokenStore, Authenticator } from './auth.js';
+import { registerTools } from './tools/index.js';
+import { registerPrompts } from './prompts/index.js';
+export function createServer(deps) {
+    const server = new McpServer({ name: 'moab-recap', version: '0.1.0' });
+    const auth = new Authenticator({ authority: deps.config.authority, client: deps.config.client }, new FileTokenStore(deps.config.configDir));
+    const api = new RecapApi(deps.config, auth);
+    registerTools(server, { config: deps.config, api, auth });
+    registerPrompts(server);
+    return server;
+}

package/dist/session-start.js

@@ -0,0 +1,44 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { sessionsDir } from './paths.js';
+import { writeSessionStateFile } from './state.js';
+import { readSessionState } from './meta.js';
+/**
+ * Хук SessionStart (`recap-mcp session-start`): stdin = JSON Claude Code (session_id, cwd, source...).
+ * Пишем session-state-файл (session_id + cwd, не затирая закреплённый проект) и просим закрепить проект,
+ * если он ещё не выбран. additionalContext отдаём в stdout как JSON (форма подтверждена по докам CC).
+ */
+export async function runSessionStart() {
+    let raw = '';
+    try {
+        raw = readFileSync(0, 'utf8');
+    }
+    catch { /* нет stdin */ }
+    let sid = '', cwd = '';
+    try {
+        const j = JSON.parse(raw);
+        sid = j.session_id ?? '';
+        cwd = j.cwd ?? '';
+    }
+    catch { /* ignore */ }
+    // 1) записать/смержить session-state (session_id + cwd); resume/clear/compact не затирают project
+    if (sid) {
+        writeSessionStateFile(join(sessionsDir(), `${sid}.json`), {
+            session_id: sid, cwd, started_at: new Date().toISOString(),
+        });
+    }
+    // 2) подсказка в контекст — нудж к /switch-project только если проект ещё не закреплён
+    const sess = sid ? readSessionState(sid) : { project: null, research_mode: false };
+    let ctx;
+    if (sess.research_mode) {
+        ctx = 'Эта сессия в research-режиме (рекапы выключены). /switch-project — выбрать проект.';
+    }
+    else if (sess.project) {
+        ctx = `Проект «${sess.project}» закреплён за этой сессией (рекапы). /moabrecap — сделать recap, /switch-project — сменить.`;
+    }
+    else {
+        ctx = 'Прежде чем работать — закрепи проект для рекапов: вызови команду /switch-project '
+            + '(она покажет список проектов и закрепит выбор за сессией). Без проекта /moabrecap не отправится.';
+    }
+    process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: ctx } }));
+}

package/dist/state.js

@@ -0,0 +1,43 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { normalizeCwdKey, sessionsDir } from './paths.js';
+function readMap(file) {
+    if (!existsSync(file))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch {
+        return {}; // битый файл — трактуем как пустой, не падаем
+    }
+}
+/** ISO-таймстамп последнего рекапа для cwd, либо null. Ключ нормализуется. */
+export function readLastRecap(file, cwd) {
+    const map = readMap(file);
+    return map[normalizeCwdKey(cwd)] ?? null;
+}
+/** Записать таймстамп последнего рекапа для cwd (merge, не затирая другие). */
+export function writeLastRecap(file, cwd, isoTs) {
+    const map = readMap(file);
+    map[normalizeCwdKey(cwd)] = isoTs;
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, JSON.stringify(map, null, 2));
+}
+/** Низкоуровневое слияние патча в session-state-файл (создаёт папку, переживает битый JSON). */
+export function writeSessionStateFile(file, patch) {
+    mkdirSync(dirname(file), { recursive: true });
+    const prev = (() => { try {
+        return JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return {};
+    } })();
+    writeFileSync(file, JSON.stringify({ ...prev, ...patch }, null, 2));
+}
+/** Закрепить проект (или research) за сессией: пишет ~/.claude-recap-sessions/<sid>.json. */
+export function writeSessionProject(sid, project, research) {
+    writeSessionStateFile(join(sessionsDir(), `${sid}.json`), {
+        project, research_mode: research, pinned_at: new Date().toISOString(),
+    });
+}

package/dist/tools/auth-tools.js

@@ -0,0 +1,31 @@
+import { run, ok } from './index.js';
+export function registerAuthTools(server, deps) {
+    server.registerTool('login', {
+        title: 'Войти',
+        description: 'Вход в MoabRecap через auth.moab.tools (device flow). Возвращает ссылку и код для подтверждения в браузере. Нужна портальная роль crew.',
+        inputSchema: {},
+    }, async () => run(async () => {
+        const dc = await deps.auth.startLogin();
+        return [
+            'Чтобы войти, откройте ссылку и подтвердите вход:',
+            dc.verification_uri_complete,
+            `Код подтверждения: ${dc.user_code}`,
+            '',
+            'После подтверждения просто повторите нужную операцию (/moabrecap или /switch-project) — вход применится автоматически.',
+        ].join('\n');
+    }));
+    server.registerTool('auth_status', {
+        title: 'Статус входа',
+        description: 'Показать, выполнен ли вход и под каким пользователем.',
+        inputSchema: {},
+        annotations: { readOnlyHint: true },
+    }, async () => run(async () => {
+        const s = await deps.auth.status();
+        return s.loggedIn ? `Вы вошли как ${s.username ?? '(неизвестно)'}.` : 'Вход не выполнен. Запустите инструмент login.';
+    }));
+    server.registerTool('auth_logout', {
+        title: 'Выйти',
+        description: 'Удалить сохранённые токены входа.',
+        inputSchema: {},
+    }, async () => { await deps.auth.logout(); return ok('Вы вышли. Сохранённые токены удалены.'); });
+}

package/dist/tools/index.js

@@ -0,0 +1,24 @@
+import { ApiError, ruRecapError } from '../errors.js';
+import { AuthRequiredError, AuthPendingError } from '../auth-errors.js';
+import { registerSendRecap } from './send-recap.js';
+import { registerSwitchProject } from './switch-project.js';
+import { registerAuthTools } from './auth-tools.js';
+export const ok = (text) => ({ content: [{ type: 'text', text }] });
+export const fail = (text) => ({ content: [{ type: 'text', text }], isError: true });
+export async function run(fn) {
+    try {
+        return ok(await fn());
+    }
+    catch (e) {
+        if (e instanceof AuthRequiredError || e instanceof AuthPendingError)
+            return fail(e.message);
+        if (e instanceof ApiError)
+            return fail(ruRecapError(e.status, e.bodyText));
+        return fail(`✗ Ошибка: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
+export function registerTools(server, deps) {
+    registerAuthTools(server, deps);
+    registerSendRecap(server, deps);
+    registerSwitchProject(server, deps);
+}

package/dist/tools/send-recap.js

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+import { run } from './index.js';
+import { collectMeta, currentSessionId, readSessionState } from '../meta.js';
+import { lastRecapFile, projectDir } from '../paths.js';
+import { readLastRecap, writeLastRecap } from '../state.js';
+import { latestTranscriptPath, readTranscript, firstUserTimestamp, activeMinutes } from '../transcript.js';
+import { computeSince } from '../window.js';
+import { collectGit } from '../git.js';
+import { ApiError } from '../errors.js';
+const TAGS = ['feature', 'bugfix', 'refactor', 'docs', 'tests', 'setup', 'infra', 'research', 'review', 'planning', 'other'];
+export function registerSendRecap(server, deps) {
+    server.registerTool('send_recap', {
+        title: 'Отправить recap',
+        description: 'Отправляет recap на сервер MoabRecap. Вызывать ТОЛЬКО из команды /moabrecap, передав уже написанное ' +
+            'summary (3-5 предложений для руководства, простым языком, с «обратной стороной»), tags, complexity, effort. ' +
+            'Метаданные, окно «с прошлого рекапа», git-стату и активные минуты тул соберёт сам.',
+        inputSchema: {
+            summary: z.string().min(1).max(1800).describe('Готовое описание для руководства, простым языком'),
+            tags: z.array(z.enum(TAGS)).min(1).max(3).describe('1-3 тега из словаря'),
+            complexityRating: z.number().int().min(1).max(5),
+            effortRating: z.number().int().min(1).max(5),
+            userHint: z.string().max(500).optional().describe('Опц. подсказка от пользователя'),
+        },
+    }, async ({ summary, tags, complexityRating, effortRating, userHint }) => run(async () => {
+        if (!deps.config.apiBase)
+            throw new Error('Не настроен RECAP_URL (запусти `recap-mcp init`).');
+        const cwd = projectDir();
+        const sid = currentSessionId();
+        const sess = readSessionState(sid);
+        if (sess.research_mode)
+            throw new Error('Сессия в research-режиме — recap не отправляется. /switch-project чтобы выбрать проект.');
+        if (!sess.project)
+            throw new Error('Проект для сессии не закреплён. Вызови /switch-project.');
+        await deps.auth.getAccessToken(); // бросит AuthRequiredError → run() покажет «запустите login»
+        const meta = collectMeta(deps.config, cwd);
+        const tPath = latestTranscriptPath();
+        const transcript = readTranscript(tPath);
+        const sessionStart = firstUserTimestamp(transcript);
+        const lastRecap = readLastRecap(lastRecapFile(), cwd);
+        const win = computeSince({ lastRecap, sessionStart });
+        const git = collectGit(cwd, win.gitSince, meta.userEmail);
+        const active = transcript ? activeMinutes(transcript, win.sinceIso, meta.clientTimestamp) : null;
+        const body = {
+            project: sess.project,
+            projectPath: meta.projectPath, clientHost: meta.clientHost, gitRemoteUrl: meta.gitRemoteUrl,
+            summary, userHint: userHint ?? null, tags,
+            complexityRating, effortRating,
+            filesChanged: git.filesChanged, linesAdded: git.linesAdded,
+            linesRemoved: git.linesRemoved, commitsCount: git.commitsCount,
+            gitStatsRaw: git.raw, source: 'manual',
+            clientTimestamp: meta.clientTimestamp,
+            sessionStart, windowStart: win.sinceIso, activeMinutes: active,
+        };
+        const res = await deps.api.postRecap(body);
+        // успех → обновляем памятку
+        writeLastRecap(lastRecapFile(), cwd, new Date().toISOString());
+        const head = summary.slice(0, 80);
+        return `✓ Recap отправлен · ${head} · ${complexityRating}/5C · ${effortRating}/5E (id=${res.id})`;
+    }));
+}
+// ApiError (409 и др.) пробрасывается в run() и превращается в дружелюбный текст;
+// памятка при ошибке НЕ обновляется (writeLastRecap не достигается).
+void ApiError;

package/dist/tools/switch-project.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { run } from './index.js';
+import { currentSessionId } from '../meta.js';
+import { writeSessionProject } from '../state.js';
+export function registerSwitchProject(server, deps) {
+    server.registerTool('list_projects', {
+        title: 'Список проектов',
+        description: 'Вернуть проекты пользователя с сервера (имя + число рекапов) для выбора в /switch-project.',
+        inputSchema: {},
+        annotations: { readOnlyHint: true },
+    }, async () => run(async () => {
+        const ps = await deps.api.myProjects();
+        if (ps.length === 0)
+            return 'Проектов пока нет.';
+        return ps.map((p, i) => `${i + 1}. ${p.project} (${p.count} recap-ов)`).join('\n');
+    }));
+    server.registerTool('pin_project', {
+        title: 'Закрепить проект',
+        description: 'Закрепить проект за текущей сессией. project="__research__" — research-режим без рекапов.',
+        inputSchema: { project: z.string().min(1).describe('Имя проекта или "__research__"') },
+    }, async ({ project }) => run(async () => {
+        const sid = currentSessionId();
+        if (!sid)
+            throw new Error('Не удалось определить session_id (нет CLAUDE_RECAP_SESSION_ID и session-state).');
+        const research = project === '__research__';
+        writeSessionProject(sid, research ? null : project, research);
+        return research
+            ? '✓ Research-сессия активирована (без recap-ов). → /rename Research'
+            : `✓ Проект «${project}» закреплён за сессией. → /rename ${project}`;
+    }));
+}

package/dist/transcript.js

@@ -0,0 +1,85 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { projectsDir } from './paths.js';
+const IDLE_MIN = 10;
+/** Первый ивент type='user' с timestamp (служебные строки без timestamp пропускаем). */
+export function firstUserTimestamp(content) {
+    for (const line of content.split('\n')) {
+        if (!line)
+            continue;
+        try {
+            const j = JSON.parse(line);
+            if (j.type === 'user' && j.timestamp)
+                return j.timestamp;
+        }
+        catch { /* пропускаем битую строку */ }
+    }
+    return null;
+}
+/** Сумма интервалов между событиями в окне [winStartIso..nowIso], интервал >IDLE_MIN не считаем. */
+export function activeMinutes(content, winStartIso, nowIso) {
+    const ws = winStartIso ? Date.parse(winStartIso) : 0; // winStartIso=null → нижняя граница = epoch (учитываем весь транскрипт)
+    const now = Date.parse(nowIso);
+    const ts = [];
+    for (const line of content.split('\n')) {
+        if (!line)
+            continue;
+        try {
+            const j = JSON.parse(line);
+            if (j.timestamp) {
+                const t = Date.parse(j.timestamp);
+                if (!isNaN(t) && t >= ws && t <= now)
+                    ts.push(t);
+            }
+        }
+        catch { /* skip */ }
+    }
+    ts.push(now);
+    ts.sort((a, b) => a - b);
+    let active = 0;
+    for (let i = 1; i < ts.length; i++) {
+        const gap = (ts[i] - ts[i - 1]) / 60000;
+        if (gap <= IDLE_MIN)
+            active += gap;
+    }
+    return Math.round(active);
+}
+/** Путь к самому свежему .jsonl-транскрипту во всех проектах, либо null. */
+export function latestTranscriptPath(dir = projectsDir()) {
+    if (!existsSync(dir))
+        return null;
+    let best = null;
+    for (const proj of readdirSync(dir)) {
+        const pdir = join(dir, proj);
+        let entries;
+        try {
+            entries = readdirSync(pdir);
+        }
+        catch {
+            continue;
+        }
+        for (const f of entries) {
+            if (!f.endsWith('.jsonl'))
+                continue;
+            const full = join(pdir, f);
+            try {
+                const m = statSync(full).mtimeMs;
+                if (!best || m > best.mtime)
+                    best = { path: full, mtime: m };
+            }
+            catch { /* skip */ }
+        }
+    }
+    return best?.path ?? null;
+}
+/** Прочитать транскрипт (или '' если нет файла). */
+export function readTranscript(path) {
+    if (!path || !existsSync(path))
+        return '';
+    try {
+        return readFileSync(path, 'utf8');
+    }
+    catch {
+        return '';
+    }
+}

package/dist/window.js

@@ -0,0 +1,13 @@
+/**
+ * Окно «с прошлого рекапа» (v2):
+ *  - last_recap есть  → since = last_recap (ВСЕГДА, даже из прошлой сессии — переживает компакт/clear/рестарт)
+ *  - иначе session_start
+ *  - иначе "12 hours ago" (gitSince), windowStart=null
+ */
+export function computeSince(input) {
+    if (input.lastRecap)
+        return { sinceIso: input.lastRecap, gitSince: input.lastRecap };
+    if (input.sessionStart)
+        return { sinceIso: input.sessionStart, gitSince: input.sessionStart };
+    return { sinceIso: null, gitSince: '12 hours ago' };
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@moabpro/recap-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for MoabRecap — manual session recaps with window-since-last-recap.",
+  "type": "module",
+  "bin": { "recap-mcp": "dist/index.js" },
+  "files": ["dist"],
+  "engines": { "node": ">=20" },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "typescript": "^5.5.0",
+    "vitest": "^3.2.4"
+  },
+  "license": "UNLICENSED",
+  "publishConfig": { "access": "public" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moab-org/Recap.git",
+    "directory": "recap-mcp"
+  },
+  "keywords": ["mcp", "claude-code", "moabrecap", "recap"]
+}