@justyork/repo-mind 0.3.0

package/dist/ui/diff.js

@@ -0,0 +1,58 @@
+import fs from 'node:fs';
+import { buildMarkdownFromDraft, resolvePublishTargetPath } from './publish.js';
+export function computeDraftDiff(index, draft) {
+    const knowledgeRoot = index.getKnowledgeRoot();
+    if (!knowledgeRoot) {
+        return { targetPath: null, isNew: true, diff: buildMarkdownFromDraft(draft) };
+    }
+    const targetPath = resolvePublishTargetPath(index, draft);
+    const proposed = buildMarkdownFromDraft(draft);
+    if (!targetPath || !fs.existsSync(targetPath)) {
+        return {
+            targetPath,
+            isNew: true,
+            diff: `--- /dev/null\n+++ ${targetPath ?? draft.slug + '.md'}\n${prefixLines(proposed, '+')}`,
+        };
+    }
+    const current = fs.readFileSync(targetPath, 'utf8');
+    if (current === proposed) {
+        return { targetPath, isNew: false, diff: '(no changes)' };
+    }
+    return {
+        targetPath,
+        isNew: false,
+        diff: unifiedDiff(targetPath, current, proposed),
+    };
+}
+function prefixLines(text, prefix) {
+    return text
+        .split('\n')
+        .map((line) => `${prefix}${line}`)
+        .join('\n');
+}
+function unifiedDiff(pathLabel, before, after) {
+    const oldLines = before.split('\n');
+    const newLines = after.split('\n');
+    const header = [`--- a/${pathLabel}`, `+++ b/${pathLabel}`];
+    if (oldLines.join('\n') === newLines.join('\n')) {
+        return '(no changes)';
+    }
+    const max = Math.max(oldLines.length, newLines.length);
+    const body = [];
+    for (let i = 0; i < max; i += 1) {
+        const oldLine = oldLines[i];
+        const newLine = newLines[i];
+        if (oldLine === newLine) {
+            body.push(` ${oldLine ?? ''}`);
+        }
+        else {
+            if (oldLine !== undefined) {
+                body.push(`-${oldLine}`);
+            }
+            if (newLine !== undefined) {
+                body.push(`+${newLine}`);
+            }
+        }
+    }
+    return [...header, `@@ -1,${oldLines.length} +1,${newLines.length} @@`, ...body].join('\n');
+}

package/dist/ui/docs-watcher.d.ts

@@ -0,0 +1,13 @@
+import type { DocIndex } from '../index/doc-index.js';
+export declare class DocsWatcher {
+    private readonly index;
+    private watcher;
+    private revision;
+    private debounceTimer;
+    private readonly subscribers;
+    constructor(index: DocIndex);
+    getRevision(): number;
+    subscribe(listener: (revision: number) => void): () => void;
+    start(knowledgeRoot: string): void;
+    stop(): Promise<void>;
+}

package/dist/ui/docs-watcher.js

@@ -0,0 +1,59 @@
+import chokidar from 'chokidar';
+const DEBOUNCE_MS = 350;
+export class DocsWatcher {
+    index;
+    watcher = null;
+    revision = 0;
+    debounceTimer = null;
+    subscribers = new Set();
+    constructor(index) {
+        this.index = index;
+    }
+    getRevision() {
+        return this.revision;
+    }
+    subscribe(listener) {
+        this.subscribers.add(listener);
+        return () => {
+            this.subscribers.delete(listener);
+        };
+    }
+    start(knowledgeRoot) {
+        if (this.watcher) {
+            return;
+        }
+        this.watcher = chokidar.watch(knowledgeRoot, {
+            ignoreInitial: true,
+            ignored: [
+                /(^|[/\\])\../,
+                '**/.repo-mind/**',
+                '**/.worktrees/**',
+                '**/node_modules/**',
+            ],
+        });
+        const scheduleRefresh = () => {
+            if (this.debounceTimer) {
+                clearTimeout(this.debounceTimer);
+            }
+            this.debounceTimer = setTimeout(() => {
+                this.index.refresh();
+                this.revision += 1;
+                for (const listener of this.subscribers) {
+                    listener(this.revision);
+                }
+            }, DEBOUNCE_MS);
+        };
+        this.watcher.on('all', scheduleRefresh);
+    }
+    async stop() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        if (this.watcher) {
+            await this.watcher.close();
+            this.watcher = null;
+        }
+        this.subscribers.clear();
+    }
+}

package/dist/ui/draft-api.d.ts

@@ -0,0 +1,7 @@
+import type { DocIndex } from '../index/doc-index.js';
+import type { DraftsDb } from './db/drafts-db.js';
+export interface DraftApiResponse {
+    status: number;
+    body: unknown;
+}
+export declare function handleDraftApi(index: DocIndex, db: DraftsDb | undefined, method: string, pathname: string, bodyRaw: string): DraftApiResponse | null;

package/dist/ui/draft-api.js

@@ -0,0 +1,413 @@
+import { runExport } from '../commands/export.js';
+import { isValidSlug } from '../index/slug.js';
+import { DOC_TYPES, isDocStatus, isDocType } from '../index/types.js';
+import { writeCatalogEmoji } from './catalog-meta.js';
+import { createFolder, createPageFile, deleteFolder, deletePageFile, movePageFile, renamePageFile } from './fs-operations.js';
+import { prepareDocFile, prepareAllDocs } from '../prepare/prepare-docs.js';
+import { syncAllDocLinks } from '../prepare/auto-links.js';
+import { getDoc } from '../tools/get-doc.js';
+import { computeDraftDiff } from './diff.js';
+import { publishDraft } from './publish.js';
+function jsonError(status, message) {
+    return { status, body: { error: message } };
+}
+function parseJsonBody(raw) {
+    if (!raw.trim()) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+function stringArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    return value.filter((item) => typeof item === 'string');
+}
+export function handleDraftApi(index, db, method, pathname, bodyRaw) {
+    if (pathname === '/api/export' && method === 'POST') {
+        const code = runExport({ force: true });
+        if (code !== 0) {
+            return jsonError(500, 'export failed');
+        }
+        return { status: 200, body: { ok: true, path: 'agents.md' } };
+    }
+    if (pathname === '/api/catalog-meta' && method === 'PUT') {
+        const body = parseJsonBody(bodyRaw);
+        if (body === null) {
+            return jsonError(400, 'invalid JSON body');
+        }
+        const folderPath = typeof body.path === 'string' ? body.path : '';
+        const emoji = typeof body.emoji === 'string' ? body.emoji : '';
+        const knowledgeRoot = index.getKnowledgeRoot();
+        if (!knowledgeRoot) {
+            return jsonError(404, 'no docs/ directory found');
+        }
+        const meta = writeCatalogEmoji(knowledgeRoot, folderPath, emoji);
+        return { status: 200, body: { meta } };
+    }
+    if (pathname === '/api/fs/folder' && method === 'POST') {
+        const body = parseJsonBody(bodyRaw);
+        if (body === null) {
+            return jsonError(400, 'invalid JSON body');
+        }
+        const parentPath = typeof body.parentPath === 'string' ? body.parentPath : '';
+        const name = typeof body.name === 'string' ? body.name : '';
+        try {
+            const result = createFolder(index, parentPath, name);
+            return { status: 201, body: { result } };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return jsonError(400, message);
+        }
+    }
+    if (pathname === '/api/fs/page' && method === 'POST') {
+        const body = parseJsonBody(bodyRaw);
+        if (body === null) {
+            return jsonError(400, 'invalid JSON body');
+        }
+        const parentPath = typeof body.parentPath === 'string' ? body.parentPath : '';
+        const name = typeof body.name === 'string' ? body.name : '';
+        const title = typeof body.title === 'string' ? body.title : undefined;
+        const templateId = typeof body.templateId === 'string' ? body.templateId : undefined;
+        if (!db) {
+            return jsonError(503, 'drafts database unavailable');
+        }
+        try {
+            const page = createPageFile(index, parentPath, name, { title, templateId });
+            const existing = db.getActiveBySlug(page.slug);
+            if (existing) {
+                return { status: 200, body: { page, draft: existing } };
+            }
+            const doc = getDoc(index, page.slug);
+            const tags = Array.isArray(doc.frontmatter?.tags)
+                ? doc.frontmatter.tags.filter((tag) => typeof tag === 'string')
+                : [];
+            const related = Array.isArray(doc.frontmatter?.related)
+                ? doc.frontmatter.related.filter((item) => typeof item === 'string')
+                : [];
+            const draft = db.create({
+                slug: page.slug,
+                type: page.type,
+                title: typeof doc.frontmatter?.title === 'string' ? doc.frontmatter.title : page.slug,
+                body: doc.body ?? '',
+                tags,
+                related,
+                target_path: page.relativePath,
+            });
+            return { status: 201, body: { page, draft } };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return jsonError(400, message);
+        }
+    }
+    if (pathname === '/api/fs/move' && method === 'POST') {
+        const body = parseJsonBody(bodyRaw);
+        if (body === null) {
+            return jsonError(400, 'invalid JSON body');
+        }
+        const fromPath = typeof body.fromPath === 'string' ? body.fromPath : '';
+        const toDir = typeof body.toDir === 'string' ? body.toDir : '';
+        try {
+            const result = movePageFile(index, fromPath, toDir);
+            return { status: 200, body: { result } };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return jsonError(400, message);
+        }
+    }
+    if (pathname === '/api/fs/rename' && method === 'POST') {
+        const body = parseJsonBody(bodyRaw);
+        if (body === null) {
+            return jsonError(400, 'invalid JSON body');
+        }
+        const pagePath = typeof body.path === 'string' ? body.path : '';
+        const newName = typeof body.newName === 'string' ? body.newName : '';
+        try {
+            const result = renamePageFile(index, pagePath, newName);
+            return { status: 200, body: { result } };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return jsonError(400, message);
+        }
+    }
+    if (pathname === '/api/fs/delete' && method === 'POST') {
+        const body = parseJsonBody(bodyRaw);
+        if (body === null) {
+            return jsonError(400, 'invalid JSON body');
+        }
+        const targetPath = typeof body.path === 'string' ? body.path : '';
+        const kind = body.kind === 'folder' ? 'folder' : body.kind === 'page' ? 'page' : null;
+        if (!kind) {
+            return jsonError(400, 'kind must be "page" or "folder"');
+        }
+        try {
+            const result = kind === 'page' ? deletePageFile(index, targetPath) : deleteFolder(index, targetPath);
+            return { status: 200, body: { result } };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return jsonError(400, message);
+        }
+    }
+    if (pathname === '/api/drafts/open' && method === 'POST') {
+        if (!db) {
+            return jsonError(503, 'drafts database unavailable');
+        }
+        const body = parseJsonBody(bodyRaw);
+        if (body === null) {
+            return jsonError(400, 'invalid JSON body');
+        }
+        const slug = typeof body.slug === 'string' ? body.slug : '';
+        if (!isValidSlug(slug)) {
+            return jsonError(400, `invalid slug: ${slug}`);
+        }
+        const existing = db.getActiveBySlug(slug);
+        if (existing) {
+            return { status: 200, body: { draft: existing } };
+        }
+        const doc = getDoc(index, slug);
+        if (!doc.found || !doc.slug || !doc.frontmatter) {
+            return jsonError(404, `document not found: ${slug}`);
+        }
+        const docRecord = index.getDocBySlug(slug);
+        try {
+            const draft = db.create({
+                slug: doc.slug,
+                type: doc.frontmatter.type,
+                title: doc.frontmatter.title ?? doc.slug,
+                body: doc.body ?? '',
+                tags: doc.frontmatter.tags ?? [],
+                related: doc.frontmatter.related ?? [],
+                forked_from: doc.slug,
+                target_path: docRecord?.relativePath ?? null,
+            });
+            return { status: 201, body: { draft } };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return jsonError(409, message);
+        }
+    }
+    if (pathname === '/api/prepare' && method === 'POST') {
+        const body = parseJsonBody(bodyRaw);
+        if (body === null) {
+            return jsonError(400, 'invalid JSON body');
+        }
+        const relativePath = typeof body.path === 'string' ? body.path : '';
+        if (!relativePath.trim()) {
+            return jsonError(400, 'path is required');
+        }
+        const typeParam = typeof body.type === 'string' ? body.type : undefined;
+        if (typeParam && !isDocType(typeParam)) {
+            return jsonError(400, `invalid type — expected one of: ${DOC_TYPES.join(', ')}`);
+        }
+        const slugParam = typeof body.slug === 'string' ? body.slug : undefined;
+        if (slugParam && !isValidSlug(slugParam)) {
+            return jsonError(400, `invalid slug: ${slugParam}`);
+        }
+        const statusParam = typeof body.status === 'string' ? body.status : undefined;
+        if (statusParam && !isDocStatus(statusParam)) {
+            return jsonError(400, `invalid status: ${statusParam}`);
+        }
+        const titleParam = typeof body.title === 'string' ? body.title : undefined;
+        try {
+            const result = prepareDocFile(index, relativePath, {
+                type: typeParam && isDocType(typeParam) ? typeParam : undefined,
+                slug: slugParam,
+                title: titleParam,
+                status: statusParam && isDocStatus(statusParam) ? statusParam : undefined,
+            });
+            return { status: 200, body: { result } };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return jsonError(400, message);
+        }
+    }
+    if (pathname === '/api/prepare-all' && method === 'POST') {
+        const body = parseJsonBody(bodyRaw);
+        const dryRun = body !== null && body.dryRun === true;
+        const result = prepareAllDocs(index, { dryRun });
+        return { status: 200, body: { result, dryRun } };
+    }
+    if (pathname === '/api/sync-links' && method === 'POST') {
+        const body = parseJsonBody(bodyRaw);
+        const dryRun = body !== null && body.dryRun === true;
+        const convertMarkdownLinks = body === null || body.convertBody === undefined ? true : body.convertBody === true;
+        const syncRelated = body === null || body.syncRelated === undefined ? true : body.syncRelated === true;
+        const result = syncAllDocLinks(index, {
+            dryRun,
+            convertMarkdownLinks,
+            syncRelated,
+        });
+        return { status: 200, body: { result, dryRun } };
+    }
+    if (!db) {
+        if (pathname.startsWith('/api/drafts')) {
+            return jsonError(503, 'drafts database unavailable');
+        }
+        return null;
+    }
+    if (!pathname.startsWith('/api/drafts')) {
+        return null;
+    }
+    if (pathname === '/api/drafts' && method === 'GET') {
+        return { status: 200, body: { drafts: db.listActive() } };
+    }
+    const diffMatch = pathname.match(/^\/api\/drafts\/([^/]+)\/diff$/);
+    if (diffMatch && method === 'GET') {
+        const id = decodeURIComponent(diffMatch[1] ?? '');
+        const draft = db.getById(id);
+        if (!draft) {
+            return jsonError(404, 'draft not found');
+        }
+        return { status: 200, body: computeDraftDiff(index, draft) };
+    }
+    if (pathname === '/api/drafts' && method === 'POST') {
+        const body = parseJsonBody(bodyRaw);
+        if (body === null) {
+            return jsonError(400, 'invalid JSON body');
+        }
+        const forkFrom = typeof body.forkFrom === 'string' ? body.forkFrom : undefined;
+        if (forkFrom) {
+            if (!isValidSlug(forkFrom)) {
+                return jsonError(400, `invalid forkFrom slug: ${forkFrom}`);
+            }
+            const existing = db.getActiveBySlug(forkFrom);
+            if (existing) {
+                return jsonError(409, `active draft already exists for slug: ${forkFrom}`);
+            }
+            const doc = getDoc(index, forkFrom);
+            if (!doc.found || !doc.slug || !doc.frontmatter) {
+                return jsonError(404, `document not found: ${forkFrom}`);
+            }
+            const docRecord = index.getDocBySlug(forkFrom);
+            try {
+                const draft = db.create({
+                    slug: doc.slug,
+                    type: doc.frontmatter.type,
+                    title: doc.frontmatter.title ?? doc.slug,
+                    body: doc.body ?? '',
+                    tags: doc.frontmatter.tags ?? [],
+                    related: doc.frontmatter.related ?? [],
+                    forked_from: doc.slug,
+                    target_path: docRecord?.relativePath ?? null,
+                });
+                return { status: 201, body: { draft } };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return jsonError(409, message);
+            }
+        }
+        const slug = typeof body.slug === 'string' ? body.slug : '';
+        const type = typeof body.type === 'string' ? body.type : '';
+        if (!isValidSlug(slug)) {
+            return jsonError(400, `invalid slug: ${slug}`);
+        }
+        if (!isDocType(type)) {
+            return jsonError(400, `invalid type — expected one of: ${DOC_TYPES.join(', ')}`);
+        }
+        try {
+            const draft = db.create({
+                slug,
+                type,
+                title: typeof body.title === 'string' ? body.title : slug,
+                body: typeof body.body === 'string' ? body.body : '',
+                tags: stringArray(body.tags),
+                related: stringArray(body.related),
+            });
+            return { status: 201, body: { draft } };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return jsonError(409, message);
+        }
+    }
+    const publishMatch = pathname.match(/^\/api\/drafts\/([^/]+)\/publish$/);
+    if (publishMatch && method === 'POST') {
+        const id = decodeURIComponent(publishMatch[1] ?? '');
+        const draft = db.getById(id);
+        if (!draft) {
+            return jsonError(404, 'draft not found');
+        }
+        try {
+            const result = publishDraft(index, draft);
+            const published = db.markPublished(id, result.path);
+            return { status: 200, body: { published, result } };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message.includes('already exists') || message.includes('broken related')) {
+                return jsonError(409, message);
+            }
+            return jsonError(400, message);
+        }
+    }
+    const idMatch = pathname.match(/^\/api\/drafts\/([^/]+)$/);
+    if (idMatch) {
+        const id = decodeURIComponent(idMatch[1] ?? '');
+        if (method === 'PUT') {
+            const body = parseJsonBody(bodyRaw);
+            if (body === null) {
+                return jsonError(400, 'invalid JSON body');
+            }
+            const type = typeof body.type === 'string' ? body.type : undefined;
+            if (type && !isDocType(type)) {
+                return jsonError(400, `invalid type: ${type}`);
+            }
+            const slug = typeof body.slug === 'string' ? body.slug : undefined;
+            if (slug && !isValidSlug(slug)) {
+                return jsonError(400, `invalid slug: ${slug}`);
+            }
+            const status = typeof body.status === 'string' ? body.status : undefined;
+            if (status && !isDocStatus(status)) {
+                return jsonError(400, `invalid status: ${status}`);
+            }
+            try {
+                const draft = db.update(id, {
+                    slug,
+                    type: type && isDocType(type) ? type : undefined,
+                    status: status && isDocStatus(status) ? status : undefined,
+                    title: typeof body.title === 'string' ? body.title : undefined,
+                    body: typeof body.body === 'string' ? body.body : undefined,
+                    tags: stringArray(body.tags),
+                    related: stringArray(body.related),
+                });
+                return { status: 200, body: { draft } };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const status = message.includes('not found') ? 404 : 409;
+                return jsonError(status, message);
+            }
+        }
+        if (method === 'DELETE') {
+            try {
+                const deleted = db.delete(id);
+                if (!deleted) {
+                    return jsonError(404, 'draft not found');
+                }
+                return { status: 200, body: { deleted: true } };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                return jsonError(400, message);
+            }
+        }
+    }
+    return jsonError(405, 'method not allowed');
+}

package/dist/ui/fs-operations.d.ts

@@ -0,0 +1,52 @@
+import type { DocIndex } from '../index/doc-index.js';
+import type { DocType } from '../index/types.js';
+export interface CreateFolderResult {
+    relativePath: string;
+    absolutePath: string;
+}
+export interface CreatePageResult {
+    relativePath: string;
+    absolutePath: string;
+    slug: string;
+    type: DocType;
+}
+export interface FsPageMutationResult {
+    relativePath: string;
+    absolutePath: string;
+    slug: string;
+    previousSlug: string;
+    slugChanged: boolean;
+    inboundWarnings: Array<{
+        slug: string;
+        title: string;
+    }>;
+    cascadeUpdated: string[];
+}
+export interface FsDeletePageResult {
+    relativePath: string;
+    slug: string;
+    inboundWarnings: Array<{
+        slug: string;
+        title: string;
+    }>;
+    cascadeUpdated: string[];
+}
+export interface FsDeleteFolderResult {
+    relativePath: string;
+    deletedSlugs: string[];
+    inboundWarnings: Array<{
+        slug: string;
+        title: string;
+    }>;
+    cascadeUpdated: string[];
+}
+export interface CreatePageOptions {
+    title?: string;
+    templateId?: string;
+}
+export declare function createFolder(index: DocIndex, parentPath: string, name: string): CreateFolderResult;
+export declare function createPageFile(index: DocIndex, parentPath: string, name: string, options?: CreatePageOptions): CreatePageResult;
+export declare function movePageFile(index: DocIndex, fromPath: string, toDir: string): FsPageMutationResult;
+export declare function renamePageFile(index: DocIndex, pagePath: string, newName: string): FsPageMutationResult;
+export declare function deletePageFile(index: DocIndex, pagePath: string): FsDeletePageResult;
+export declare function deleteFolder(index: DocIndex, folderPath: string): FsDeleteFolderResult;