elanous 0.2.0 → 0.2.4

package/src/design/lint-artifact-run.ts

@@ -5,18 +5,23 @@
 // ⛔ 이 파일은 화면에 «찍지 않는다» — 호출자가 표현을 소유한다.
 
 import { existsSync, readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 
 import { debug } from '../debug/log.js';
-import { reportDesignTokens } from './design-tokens.js';
+import { readCssRootTokens } from './css-root-tokens.js';
+import { reportDesignTokens, type DeclaredToken } from './design-tokens.js';
 import { lintArtifact, type LintResult } from './lint-artifact.js';
 
 export interface LintDesignInput {
   readonly htmlPath: string;
   readonly cssPath?: string;
   readonly designPath?: string;
+  /** 고른 디자인 시스템의 `tokens.css` — 안 주면 씨앗의 `## Design direction` 절 `- tokens:` 줄에서 찾는다. */
+  readonly tokensPath?: string;
 }
 
+export type TokensSource = 'flag' | 'design-direction' | 'none';
+
 export interface LintDesignRun extends LintResult {
   readonly htmlPath: string;
   readonly cssPath: string;
@@ -24,10 +29,31 @@ export interface LintDesignRun extends LintResult {
   readonly cssFound: boolean;
   readonly designPath: string;
   readonly designFound: boolean;
+  readonly tokensPath: string | null;
+  readonly tokensFound: boolean;
+  readonly tokensSource: TokensSource;
+  /** 씨앗 절 토큰 ⊕ `tokens.css` `:root` 토큰(같은 이름이면 씨앗이 이긴다). */
   readonly paletteCount: number;
   readonly typographyCount: number;
 }
 
+/** 씨앗 `## Design direction` 절의 `- tokens: <상대 경로>` — 씨앗 폴더 기준. 없으면 null. */
+export function tokensPathFromDesignDirection(designMarkdown: string, designPath: string): string | null {
+  let inSection = false;
+  for (const line of designMarkdown.split(/\r?\n/)) {
+    if (/^##\s/.test(line)) { inSection = /^##\s+Design direction\s*$/i.test(line); continue; }
+    if (!inSection) continue;
+    const match = /^\s*-\s*tokens:\s*(\S.*?)\s*$/.exec(line);
+    if (match) return resolve(dirname(designPath), match[1]);
+  }
+  return null;
+}
+
+function mergeTokens(primary: readonly DeclaredToken[], secondary: readonly DeclaredToken[]): DeclaredToken[] {
+  const names = new Set(primary.map((t) => t.name));
+  return [...primary, ...secondary.filter((t) => !names.has(t.name))];
+}
+
 /** @throws HTML 을 못 읽으면 던진다 — 호출자가 표현한다. */
 export function runLintDesign(input: LintDesignInput): LintDesignRun {
   try {
@@ -41,23 +67,36 @@ export function runLintDesign(input: LintDesignInput): LintDesignRun {
 
     const designPath = input.designPath ?? join(dirname(input.htmlPath), 'DESIGN.md');
     const designFound = existsSync(designPath);
-    const tokens = designFound ? reportDesignTokens(readFileSync(designPath, 'utf8')) : null;
+    const designMarkdown = designFound ? readFileSync(designPath, 'utf8') : '';
+    const tokens = designFound ? reportDesignTokens(designMarkdown) : null;
+
+    // ⛔ 토큰 파일이 없으면 지금과 «같은» 결과 — 씨앗 절 토큰만 쓴다.
+    const directionTokensPath = designFound ? tokensPathFromDesignDirection(designMarkdown, designPath) : null;
+    const tokensPath = input.tokensPath ?? directionTokensPath;
+    const tokensSource: TokensSource = input.tokensPath !== undefined ? 'flag' : directionTokensPath ? 'design-direction' : 'none';
+    const tokensFound = tokensPath !== null && existsSync(tokensPath);
+    const rootTokens = tokensFound ? readCssRootTokens(readFileSync(tokensPath, 'utf8')) : null;
+    const palette = mergeTokens(tokens?.palette.tokens ?? [], rootTokens?.palette ?? []);
+    const typography = mergeTokens(tokens?.typography.tokens ?? [], rootTokens?.typography ?? []);
 
     const result = lintArtifact({
       html, css,
-      declaredTokens: tokens ? [...tokens.palette.tokens, ...tokens.typography.tokens] : undefined,
+      declaredTokens: tokens || rootTokens ? [...palette, ...typography] : undefined,
     });
 
     const run = {
       ...result,
       htmlPath: input.htmlPath, cssPath, cssFound, designPath, designFound,
-      paletteCount: tokens?.palette.tokens.length ?? 0,
-      typographyCount: tokens?.typography.tokens.length ?? 0,
+      tokensPath, tokensFound, tokensSource,
+      paletteCount: palette.length,
+      typographyCount: typography.length,
     };
     debug.log('design.lint', 'done', {
       htmlPath: run.htmlPath,
       cssPath: run.cssPath,
       designPath: run.designPath,
+      tokensSource: run.tokensSource,
+      tokensFound: run.tokensFound,
       p0Count: run.p0Count,
       advisoryCount: run.advisoryCount,
       uncheckedRuleCount: run.skipped.length,
@@ -75,6 +114,7 @@ export function formatLintDesignRun(r: LintDesignRun): string[] {
     `◆ design-lint — ${r.htmlPath}`,
     `  CSS     ${r.cssFound ? r.cssPath : '🔴 못 찾았다 — CSS 규칙은 «검사 안 됨»이다'}`,
     `  씨앗    ${r.designFound ? `${r.designPath} (토큰 ${r.paletteCount}색 · ${r.typographyCount}타이포)` : '🔴 없다 — 씨앗 의존 규칙은 «검사 안 됨»'}`,
+    `  토큰    ${r.tokensPath === null ? '없음 (방향 절에 tokens 줄이 없다)' : `${r.tokensFound ? r.tokensPath : `🔴 못 찾았다 — ${r.tokensPath}`} (출처 ${r.tokensSource})`}`,
     `  ── 결과 ──`,
     `  ⛔ P0 위반   ${r.p0Count}`,
     `  ⚠️ advisory  ${r.advisoryCount}`,

package/src/design/lint-artifact.ts

@@ -164,7 +164,11 @@ export function lintArtifact(input: LintInput): LintResult {
   // ⑤ 라운드 카드 + 색깔 좌측 보더 — ⛔ «같은 규칙 블록» 안에서만 본다
   for (const m of css.matchAll(/\{[^}]*\}/g)) {
     const b = m[0];
-    if (/border-radius\s*:\s*(?!0)/.test(b) && /border-left\s*:\s*[^;]*(#|rgb|var\()/.test(b)) {
+    // 🩸 2026-09-28 E0·E1: 두 판 모두 «커피콩 그림»(`border-radius: 50%` 타원 ⊕ 한쪽 선)에 걸렸다.
+    //    카드 타일은 둥근 «모서리»지 타원이 아니다 — 30% 이상 퍼센트·`/` 타원 반경은 그림으로 보고 뺀다.
+    const radius = /border-radius\s*:\s*([^;}]*)/.exec(b)?.[1] ?? '';
+    const shape = radius.includes('/') || [...radius.matchAll(/(\d+(?:\.\d+)?)%/g)].some((p) => Number(p[1]) >= 30);
+    if (/border-radius\s*:\s*(?!0)/.test(b) && !shape && /border-left\s*:\s*[^;]*(#|rgb|var\()/.test(b)) {
       push('rounded-card-left-accent', 'p0', { line: lineOf(css, m.index ?? 0), evidence: b.replace(/\s+/g, ' ').slice(0, 90) },
         '라운드 + 색 좌측 보더는 전형적 「AI 대시보드 타일」이다 — 둘 중 하나를 뺀다');
     }

package/src/design/open-design-client.ts

@@ -0,0 +1,247 @@
+import { readFileSync } from 'node:fs';
+
+import { debug } from '../debug/log.js';
+import { getUserConfig, type UserConfig } from '../user-config.js';
+
+export const OPEN_DESIGN_TIMEOUT_MS = 30_000;
+
+export interface OpenDesignConnection {
+  url: string;
+  token: string;
+}
+
+export interface OpenDesignFailure {
+  ok: false;
+  status: number;
+  reason: string;
+}
+
+export interface OpenDesignProject {
+  id: string;
+  name: string;
+  designSystemId: string;
+  conversationId?: string;
+}
+
+export interface OpenDesignRun {
+  runId: string;
+  status?: string;
+  designSystemId?: string;
+  agentId?: string;
+  [key: string]: unknown;
+}
+
+export interface OpenDesignFileEntry {
+  name: string;
+  size?: number;
+  [key: string]: unknown;
+}
+
+export interface OpenDesignClientDeps {
+  fetch?: typeof fetch;
+  now?: () => number;
+  readFile?: (path: string) => string;
+  config?: Pick<UserConfig, 'design'>;
+  timeoutMs?: number;
+}
+
+export type OpenDesignResult<T> = ({ ok: true } & T) | OpenDesignFailure;
+
+const REASON_LIMIT = 200;
+
+/** 주소가 없으면 null — OpenDesign 은 꺼진 것이다. 토큰 값은 반환 객체에만 있고 로그·오류에 싣지 않는다. */
+export function openDesignConfig(deps: OpenDesignClientDeps = {}): OpenDesignConnection | null {
+  const design = (deps.config ?? getUserConfig()).design?.openDesign;
+  const url = design?.url?.trim();
+  if (!url) return null;
+  const tokenFile = design?.tokenFile?.trim();
+  if (!tokenFile) return null;
+  const readFile = deps.readFile ?? ((path: string) => readFileSync(path, 'utf8'));
+  let token: string;
+  try {
+    const line = readFile(tokenFile).split(/\r?\n/).find((row) => row.trim().length > 0);
+    token = line?.trim() ?? '';
+  } catch {
+    return null;
+  }
+  if (!token) return null;
+  return { url: url.replace(/\/+$/, ''), token };
+}
+
+function clipReason(body: string, token: string): string {
+  const flat = body.replaceAll(token, '[redacted]').replace(/\s+/g, ' ').trim();
+  return flat.length <= REASON_LIMIT ? flat : flat.slice(0, REASON_LIMIT);
+}
+
+async function requestJson(
+  connection: OpenDesignConnection,
+  method: string,
+  path: string,
+  body: unknown | undefined,
+  deps: OpenDesignClientDeps,
+): Promise<OpenDesignResult<{ body: unknown }>> {
+  const fetchImpl = deps.fetch ?? fetch;
+  const timeoutMs = deps.timeoutMs ?? OPEN_DESIGN_TIMEOUT_MS;
+  const started = (deps.now ?? Date.now)();
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let status = 0;
+  try {
+    const response = await fetchImpl(`${connection.url}${path}`, {
+      method,
+      headers: {
+        Authorization: `Bearer ${connection.token}`,
+        Accept: 'application/json',
+        ...(body === undefined ? {} : { 'Content-Type': 'application/json' }),
+      },
+      ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+      signal: controller.signal,
+    });
+    status = response.status;
+    const text = await response.text();
+    const ms = (deps.now ?? Date.now)() - started;
+    debug.log('design.open-design', method.toLowerCase(), { path, status, ms });
+    if (!response.ok) {
+      return { ok: false, status, reason: clipReason(text, connection.token) || response.statusText || 'request failed' };
+    }
+    if (!text.trim()) return { ok: true, body: {} };
+    try {
+      return { ok: true, body: JSON.parse(text) as unknown };
+    } catch {
+      return { ok: false, status, reason: 'response was not json' };
+    }
+  } catch (error) {
+    const ms = (deps.now ?? Date.now)() - started;
+    const aborted = error instanceof Error && error.name === 'AbortError';
+    status = aborted ? 0 : status;
+    debug.log('design.open-design', aborted ? 'timeout' : 'error', { path, status, ms });
+    return { ok: false, status, reason: aborted ? 'timeout' : 'request failed' };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function createProject(
+  input: { id: string; name: string; designSystemId: string },
+  connection: OpenDesignConnection,
+  deps: OpenDesignClientDeps = {},
+): Promise<OpenDesignResult<{ project: OpenDesignProject; conversationId?: string }>> {
+  const result = await requestJson(connection, 'POST', '/api/projects', {
+    id: input.id,
+    name: input.name,
+    designSystemId: input.designSystemId,
+    skipDiscoveryBrief: true,
+  }, deps);
+  if (!result.ok) return result;
+  const root = result.body as { project?: OpenDesignProject; conversationId?: string };
+  const project = root.project;
+  if (!project || typeof project.id !== 'string') {
+    return { ok: false, status: 200, reason: 'project missing' };
+  }
+  return {
+    ok: true,
+    project: {
+      id: project.id,
+      name: project.name,
+      designSystemId: project.designSystemId,
+      ...(typeof root.conversationId === 'string' ? { conversationId: root.conversationId } : {}),
+    },
+    ...(typeof root.conversationId === 'string' ? { conversationId: root.conversationId } : {}),
+  };
+}
+
+export async function startRun(
+  input: { projectId: string; message: string; agentId: string },
+  connection: OpenDesignConnection,
+  deps: OpenDesignClientDeps = {},
+): Promise<OpenDesignResult<{ runId: string }>> {
+  const result = await requestJson(connection, 'POST', '/api/runs', {
+    projectId: input.projectId,
+    message: input.message,
+    agentId: input.agentId,
+  }, deps);
+  if (!result.ok) return result;
+  const runId = (result.body as { runId?: unknown }).runId;
+  if (typeof runId !== 'string' || !runId) return { ok: false, status: 200, reason: 'runId missing' };
+  return { ok: true, runId };
+}
+
+export async function getRun(
+  runId: string,
+  connection: OpenDesignConnection,
+  deps: OpenDesignClientDeps = {},
+): Promise<OpenDesignResult<{ run: OpenDesignRun }>> {
+  const result = await requestJson(connection, 'GET', `/api/runs/${encodeURIComponent(runId)}`, undefined, deps);
+  if (!result.ok) return result;
+  const body = result.body as Record<string, unknown>;
+  const status = typeof body.status === 'string' ? body.status : undefined;
+  return {
+    ok: true,
+    run: {
+      ...body,
+      runId: typeof body.runId === 'string' ? body.runId : runId,
+      ...(status ? { status } : {}),
+      ...(typeof body.designSystemId === 'string' ? { designSystemId: body.designSystemId } : {}),
+      ...(typeof body.agentId === 'string' ? { agentId: body.agentId } : {}),
+    },
+  };
+}
+
+export async function listFiles(
+  projectId: string,
+  connection: OpenDesignConnection,
+  deps: OpenDesignClientDeps = {},
+): Promise<OpenDesignResult<{ files: OpenDesignFileEntry[] }>> {
+  const result = await requestJson(connection, 'GET', `/api/projects/${encodeURIComponent(projectId)}/files`, undefined, deps);
+  if (!result.ok) return result;
+  const files = (result.body as { files?: unknown }).files;
+  if (!Array.isArray(files)) return { ok: false, status: 200, reason: 'files missing' };
+  return {
+    ok: true,
+    files: files.flatMap((entry) => {
+      if (!entry || typeof entry !== 'object') return [];
+      const file = entry as OpenDesignFileEntry;
+      return typeof file.name === 'string' ? [file] : [];
+    }),
+  };
+}
+
+export async function readFile(
+  projectId: string,
+  name: string,
+  connection: OpenDesignConnection,
+  deps: OpenDesignClientDeps = {},
+): Promise<OpenDesignResult<{ text: string; contentType?: string }>> {
+  const fetchImpl = deps.fetch ?? fetch;
+  const timeoutMs = deps.timeoutMs ?? OPEN_DESIGN_TIMEOUT_MS;
+  const path = `/api/projects/${encodeURIComponent(projectId)}/files/${encodeURIComponent(name)}`;
+  const started = (deps.now ?? Date.now)();
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let status = 0;
+  try {
+    const response = await fetchImpl(`${connection.url}${path}`, {
+      method: 'GET',
+      headers: {
+        Authorization: `Bearer ${connection.token}`,
+        Accept: 'text/html, text/plain, */*',
+      },
+      signal: controller.signal,
+    });
+    status = response.status;
+    const text = await response.text();
+    const ms = (deps.now ?? Date.now)() - started;
+    debug.log('design.open-design', 'get', { path, status, ms });
+    if (!response.ok) {
+      return { ok: false, status, reason: clipReason(text, connection.token) || response.statusText || 'request failed' };
+    }
+    return { ok: true, text, ...(response.headers.get('content-type') ? { contentType: response.headers.get('content-type') ?? undefined } : {}) };
+  } catch (error) {
+    const ms = (deps.now ?? Date.now)() - started;
+    const aborted = error instanceof Error && error.name === 'AbortError';
+    debug.log('design.open-design', aborted ? 'timeout' : 'error', { path, status, ms });
+    return { ok: false, status, reason: aborted ? 'timeout' : 'request failed' };
+  } finally {
+    clearTimeout(timer);
+  }
+}