@hanmariyang/drafting 1.6.2

package/api/dist/lib/templates.js

@@ -0,0 +1,85 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { config } from "./config.js";
+import { getSetting, setSetting } from "../db/repos.js";
+// Interview templates live as external JSON files (G-06: NOT hardcoded), so the
+// community can add/edit document types without touching source. Loaded once at
+// boot. Custom templates (edited in-app) are stored in the DB and overlaid on
+// top of the file templates by id — so users can customize without file edits.
+let fileCache = null;
+function loadFileTemplates() {
+    if (fileCache)
+        return fileCache;
+    return reloadTemplates();
+}
+export function reloadTemplates() {
+    const map = new Map();
+    const dir = config.templatesDir;
+    if (fs.existsSync(dir)) {
+        for (const file of fs.readdirSync(dir)) {
+            if (!file.endsWith('.json'))
+                continue;
+            const raw = fs.readFileSync(path.join(dir, file), 'utf8');
+            try {
+                const tpl = JSON.parse(raw);
+                if (tpl.id && tpl.docType && Array.isArray(tpl.questions)) {
+                    map.set(tpl.id, tpl);
+                }
+            }
+            catch {
+                // skip malformed template file
+            }
+        }
+    }
+    fileCache = map;
+    return map;
+}
+function customStore() {
+    return getSetting('custom_templates') ?? {};
+}
+/** File templates with DB custom templates overlaid (custom wins by id). */
+function effectiveTemplates() {
+    const map = new Map(loadFileTemplates());
+    for (const [id, t] of Object.entries(customStore()))
+        map.set(id, t);
+    return map;
+}
+/** source of an id in the effective set — for the UI. */
+export function templateSource(id) {
+    const isCustom = id in customStore();
+    const isFile = loadFileTemplates().has(id);
+    if (isCustom && isFile)
+        return 'override';
+    return isCustom ? 'custom' : 'file';
+}
+export function loadTemplates() {
+    return effectiveTemplates();
+}
+export function listTemplates() {
+    return [...effectiveTemplates().values()].sort((a, b) => a.docType.localeCompare(b.docType));
+}
+export function getTemplate(id) {
+    return effectiveTemplates().get(id) ?? null;
+}
+export function getTemplateForType(docType) {
+    for (const t of effectiveTemplates().values()) {
+        if (t.docType === docType)
+            return t;
+    }
+    return null;
+}
+// ── custom template mutations (in-app editor) ────────────────────────────────
+export function saveCustomTemplate(t) {
+    const store = customStore();
+    store[t.id] = t;
+    setSetting('custom_templates', store);
+}
+/** Delete a custom template. For an override, this reverts to the file version. */
+export function deleteCustomTemplate(id) {
+    const store = customStore();
+    if (!(id in store))
+        return false;
+    delete store[id];
+    setSetting('custom_templates', store);
+    return true;
+}

package/api/dist/lib/types.js

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

package/api/dist/lib/wireframes.js

@@ -0,0 +1,137 @@
+// Derived wireframe render data (§5.1) — deterministic, AI-free. Input: accepted
+// (and proposed, flagged) IA pages + their linked feature content + flow steps.
+// Content is SEEDED from feature titles/bodies; hotspots (→ PG-nn) come from the
+// flow. Same input → same output. The React <WireframeGrid> paints this shape.
+import * as repo from "../db/repos.js";
+import { lintProject } from "./lint.js";
+function meta(i) {
+    try {
+        return JSON.parse(i.meta || '{}');
+    }
+    catch {
+        return {};
+    }
+}
+function bodyLines(i) {
+    return i.body
+        .split('\n')
+        .map((l) => l.replace(/^[·\-*]\s*/, '').trim())
+        .filter(Boolean);
+}
+/**
+ * Build a flat, wireframe-ready list for a project. Pages that are 'rejected' are
+ * excluded; accepted + proposed pages are both included (proposed flagged so the
+ * UI can dash them — mirrors the IA sitemap proposal).
+ */
+export function deriveWireframes(projectId) {
+    const items = repo.listProjectItems(projectId);
+    const byRef = new Map();
+    for (const it of items)
+        byRef.set(it.ref_id, it);
+    // page ref -> outgoing hotspot (from consecutive page-bearing MAIN steps)
+    const outgoing = new Map();
+    const flowsForPage = new Map();
+    const flowItems = items.filter((i) => i.kind === 'flow');
+    for (const flow of flowItems) {
+        const steps = items
+            .filter((i) => i.kind === 'step' && i.parent_id === flow.id)
+            .sort((a, b) => a.position - b.position);
+        let prevPage = null;
+        for (const st of steps) {
+            const m = meta(st);
+            if (m.branch)
+                continue; // branch steps don't drive the main hotspot chain
+            if (!m.page)
+                continue;
+            if (!flowsForPage.has(m.page))
+                flowsForPage.set(m.page, new Set());
+            flowsForPage.get(m.page).add(flow.ref_id);
+            if (prevPage && prevPage !== m.page && !outgoing.has(prevPage)) {
+                outgoing.set(prevPage, m.page);
+            }
+            prevPage = m.page;
+        }
+    }
+    const reqIds = repo.reqIdsForProject(projectId).map((r) => r.id);
+    const violations = lintProject(items, reqIds);
+    const pageWarning = new Map();
+    for (const v of violations) {
+        if (v.code === 'W-UNREACHED-PAGE')
+            pageWarning.set(v.refs[0], '이 화면에 도달하는 플로우 없음');
+        else if (v.code === 'W-EMPTY-PAGE' && !pageWarning.has(v.refs[0]))
+            pageWarning.set(v.refs[0], '연결된 기능 없음');
+    }
+    const pages = items
+        .filter((i) => i.kind === 'page' && i.status !== 'rejected')
+        .sort((a, b) => a.position - b.position);
+    return pages.map((page) => {
+        const m = meta(page);
+        const featureRefs = m.links?.features ?? [];
+        const features = featureRefs.map((r) => byRef.get(r)).filter((x) => !!x);
+        const toPage = outgoing.get(page.ref_id) ?? null;
+        const hotspot = toPage ? { toPage, label: `→ ${toPage}` } : null;
+        return {
+            ref: page.ref_id,
+            itemId: page.id,
+            title: page.title,
+            pageType: (m.page_type ?? 'GENERIC'),
+            status: page.status === 'accepted' ? 'accepted' : 'proposed',
+            featureRefs,
+            flowRefs: [...(flowsForPage.get(page.ref_id) ?? [])],
+            hotspot,
+            lintWarning: pageWarning.get(page.ref_id) ?? null,
+            seed: seedFor((m.page_type ?? 'GENERIC'), page, features, hotspot),
+        };
+    });
+}
+function seedFor(type, page, features, hotspot) {
+    const labels = features.map((f) => f.title);
+    const lines = features.flatMap((f) => bodyLines(f));
+    const cta = hotspot ? '다음 단계로' : '확인';
+    switch (type) {
+        case 'LIST':
+            return {
+                search: `${page.title} 검색`,
+                rows: (labels.length ? labels : [page.title]).slice(0, 3).map((t, i) => ({
+                    title: t,
+                    meta: `${i + 1}번`,
+                    action: i === 0 && hotspot ? '열기' : '보기',
+                    hot: i === 0 && hotspot ? hotspot.label : undefined,
+                })),
+            };
+        case 'DETAIL':
+            return {
+                detailTitle: labels[0] ?? page.title,
+                slots: ['옵션 A', '옵션 B', '옵션 C'].map((label, i) => ({
+                    label,
+                    state: i === 1 ? 'on' : i === 2 ? 'dis' : 'idle',
+                })),
+                blocks: lines.slice(0, 2),
+                cta: hotspot ? `${cta}` : page.title,
+            };
+        case 'FORM':
+            return {
+                fields: (lines.length ? lines : labels).slice(0, 4).map((label, i) => ({
+                    label,
+                    value: i === 0 ? page.title : '입력값',
+                })),
+                cta: hotspot ? '제출' : '저장',
+            };
+        case 'DASH':
+            return {
+                stats: (labels.length ? labels : ['지표 A', '지표 B', '지표 C'])
+                    .slice(0, 3)
+                    .map((label, i) => ({ value: `${(i + 5) * 12}%`, label })),
+                bars: [40, 65, 80, 55, 90],
+            };
+        case 'SETTINGS':
+            return {
+                toggles: (lines.length ? lines : labels).slice(0, 3).map((label, i) => ({
+                    label,
+                    on: i < 2,
+                })),
+            };
+        default:
+            return { blocks: lines.length ? lines : labels.length ? labels : [page.title] };
+    }
+}

package/api/dist/providers/byok/anthropic.js

@@ -0,0 +1,75 @@
+import { iterateSse } from "../sse.js";
+const BASE = 'https://api.anthropic.com/v1';
+export class AnthropicProvider {
+    id = 'anthropic';
+    apiKey;
+    constructor(apiKey) {
+        this.apiKey = apiKey;
+    }
+    headers() {
+        return {
+            'x-api-key': this.apiKey,
+            'anthropic-version': '2023-06-01',
+            'content-type': 'application/json',
+        };
+    }
+    async *streamChat(params) {
+        const system = params.messages
+            .filter((m) => m.role === 'system')
+            .map((m) => m.content)
+            .join('\n\n');
+        const messages = params.messages
+            .filter((m) => m.role !== 'system')
+            .map((m) => ({ role: m.role, content: m.content }));
+        const res = await fetch(`${BASE}/messages`, {
+            method: 'POST',
+            headers: this.headers(),
+            signal: params.signal,
+            body: JSON.stringify({
+                model: params.model,
+                max_tokens: params.maxTokens ?? 4096,
+                system: system || undefined,
+                messages,
+                stream: true,
+            }),
+        });
+        if (!res.ok) {
+            throw new Error(`Anthropic ${res.status}: ${await res.text()}`);
+        }
+        for await (const data of iterateSse(res)) {
+            if (data === '[DONE]')
+                break;
+            try {
+                const evt = JSON.parse(data);
+                if (evt.type === 'content_block_delta' && evt.delta?.type === 'text_delta') {
+                    yield evt.delta.text;
+                }
+                else if (evt.type === 'error') {
+                    throw new Error(evt.error?.message ?? 'anthropic stream error');
+                }
+            }
+            catch {
+                // non-JSON keep-alive line; ignore
+            }
+        }
+    }
+    async testConnection(model) {
+        try {
+            const res = await fetch(`${BASE}/messages`, {
+                method: 'POST',
+                headers: this.headers(),
+                body: JSON.stringify({
+                    model,
+                    max_tokens: 1,
+                    messages: [{ role: 'user', content: 'ping' }],
+                }),
+            });
+            if (res.ok)
+                return { ok: true };
+            return { ok: false, detail: `${res.status}: ${(await res.text()).slice(0, 200)}` };
+        }
+        catch (e) {
+            return { ok: false, detail: e.message };
+        }
+    }
+}

package/api/dist/providers/byok/openai-compat.js

@@ -0,0 +1,95 @@
+import { iterateSse } from "../sse.js";
+import { humanizeProviderError } from "../../lib/provider-errors.js";
+/**
+ * Shared implementation for OpenAI-compatible chat/completions endpoints.
+ * OpenAI and OpenRouter differ only in base URL + optional extra headers.
+ */
+export class OpenAICompatProvider {
+    id;
+    apiKey;
+    base;
+    extraHeaders;
+    constructor(id, apiKey, base, extraHeaders = {}) {
+        this.id = id;
+        this.apiKey = apiKey;
+        this.base = base;
+        this.extraHeaders = extraHeaders;
+    }
+    headers() {
+        return {
+            authorization: `Bearer ${this.apiKey}`,
+            'content-type': 'application/json',
+            ...this.extraHeaders,
+        };
+    }
+    async *streamChat(params) {
+        const res = await fetch(`${this.base}/chat/completions`, {
+            method: 'POST',
+            headers: this.headers(),
+            signal: params.signal,
+            body: JSON.stringify({
+                model: params.model,
+                max_tokens: params.maxTokens ?? 4096,
+                messages: params.messages.map((m) => ({ role: m.role, content: m.content })),
+                stream: true,
+            }),
+        });
+        if (!res.ok) {
+            throw new Error(humanizeProviderError(res.status, await res.text()));
+        }
+        for await (const data of iterateSse(res)) {
+            if (data === '[DONE]')
+                break;
+            try {
+                const evt = JSON.parse(data);
+                const delta = evt.choices?.[0]?.delta?.content;
+                if (typeof delta === 'string' && delta.length)
+                    yield delta;
+            }
+            catch {
+                // keep-alive / non-JSON line
+            }
+        }
+    }
+    async testConnection(model) {
+        try {
+            const res = await fetch(`${this.base}/chat/completions`, {
+                method: 'POST',
+                headers: this.headers(),
+                body: JSON.stringify({
+                    model,
+                    max_tokens: 1,
+                    messages: [{ role: 'user', content: 'ping' }],
+                }),
+            });
+            if (res.ok)
+                return { ok: true };
+            return { ok: false, detail: `${res.status}: ${(await res.text()).slice(0, 200)}` };
+        }
+        catch (e) {
+            return { ok: false, detail: e.message };
+        }
+    }
+}
+export class OpenAIProvider extends OpenAICompatProvider {
+    // base 를 넘기면 OpenAI 호환 게이트웨이(LiteLLM·Azure·사내 프록시)를 그대로 사용한다.
+    // 게이트웨이가 표준 Bearer 외 다른 헤더를 요구하면 extraHeaders 로 주입한다.
+    constructor(apiKey, base, extraHeaders = {}) {
+        super('openai', apiKey, normalizeBase(base) ?? 'https://api.openai.com/v1', extraHeaders);
+    }
+}
+/** 사용자가 붙인 base 를 정규화 — 끝 슬래시 제거. 빈 값이면 null(기본값 사용). */
+function normalizeBase(base) {
+    const b = (base ?? '').trim().replace(/\/+$/, '');
+    return b || null;
+}
+export class OpenRouterProvider extends OpenAICompatProvider {
+    // base 를 넘기면 OpenAI 호환 게이트웨이(LiteLLM 등)로 라우팅. 안 넘기면 openrouter.ai.
+    constructor(apiKey, base, extraHeaders = {}) {
+        super('openrouter', apiKey, normalizeBase(base) ?? 'https://openrouter.ai/api/v1', {
+            'HTTP-Referer': 'https://github.com/hanmariyang/drafting',
+            'X-Title': 'Drafting',
+            ...extraHeaders,
+        });
+    }
+}