elanous 0.2.0 → 0.2.4

package/src/design/apply-direction.ts

@@ -0,0 +1,209 @@
+import { randomUUID } from 'node:crypto';
+import { chmodSync, closeSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmdirSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { debug } from '../debug/log.js';
+import { listAllDesignDirections, listDesignDirections, parseDeclaredDirection, writeDeclaredDirection, writeDeclaredSystemDirection } from './design-directions.js';
+import { libraryDir } from './design-library.js';
+import { defaultDesignSystemsDir, listDesignSystems, type DesignSystem } from './design-systems.js';
+
+export interface ApplyDesignDirectionDeps {
+  readFile: (path: string, encoding: 'utf8') => string;
+  writeFile: (path: string, contents: string, options?: { exclusive?: boolean; onCreated?: () => void }) => void;
+  readdir: (path: string) => readonly string[];
+  mkdir: (path: string) => void;
+  removeFile: (path: string) => void;
+  removeDir: (path: string) => void;
+  renameFile: (from: string, to: string) => void;
+  documentTarget: (path: string) => { path: string; mode?: number };
+  setFileMode: (path: string, mode: number) => void;
+}
+
+export interface ApplyDesignDirectionOptions {
+  systemsDir?: string;
+  librarySystemsDir?: string;
+  deps?: Partial<ApplyDesignDirectionDeps>;
+}
+
+export type ApplyDesignDirectionResult =
+  | { ok: true; documentPath: string; direction: string }
+  | { ok: false; reason: 'cannot-read' | 'cannot-write' | 'unknown-direction' | 'conflicting-system-file'; documentPath: string; path?: string; availableDirections?: string[] };
+
+const liveDeps: ApplyDesignDirectionDeps = {
+  readFile: (path) => readFileSync(path, 'utf8'),
+  writeFile: (path, contents, options) => {
+    if (!options?.exclusive) {
+      writeFileSync(path, contents, 'utf8');
+      return;
+    }
+    const fd = openSync(path, 'wx');
+    try {
+      options.onCreated?.();
+      writeFileSync(fd, contents, 'utf8');
+    } finally { closeSync(fd); }
+  },
+  readdir: (path) => readdirSync(path),
+  mkdir: (path) => mkdirSync(path),
+  removeFile: (path) => unlinkSync(path),
+  removeDir: (path) => rmdirSync(path),
+  renameFile: (from, to) => renameSync(from, to),
+  documentTarget: (path) => {
+    const real = realpathSync(path);
+    return { path: real, mode: statSync(real).mode & 0o7777 };
+  },
+  setFileMode: (path, mode) => chmodSync(path, mode),
+};
+
+const filesystemKeys = ['readFile', 'writeFile', 'readdir', 'mkdir', 'removeFile', 'removeDir', 'renameFile'] as const;
+
+function hasCode(error: unknown, code: string): boolean {
+  return typeof error === 'object' && error !== null && 'code' in error && error.code === code;
+}
+
+/** Select a theme or install a bundled web system into the repository owning documentPath.
+ * System files are conflict-checked before writing; newly created files/dirs are rolled back
+ * if the staged DESIGN.md replacement cannot be committed. */
+export function applyDesignDirection(
+  documentPath: string,
+  directionId: string,
+  options: ApplyDesignDirectionOptions = {},
+): ApplyDesignDirectionResult {
+  const systemsDir = options.systemsDir ?? defaultDesignSystemsDir();
+  const librarySystemsDir = options.librarySystemsDir ?? libraryDir();
+  const overrides = options.deps ?? {};
+  const deps = { ...liveDeps, ...overrides };
+  const directions = listAllDesignDirections({ systemsDir, librarySystemsDir });
+  const themes = listDesignDirections();
+  const themeIds = new Set(themes.map((theme) => theme.id));
+  const bundled = listDesignSystems(systemsDir).filter((system) => !themeIds.has(system.id));
+  const bundledIds = new Set(bundled.map((system) => system.id));
+  const library = listDesignSystems(librarySystemsDir)
+    .filter((system) => !themeIds.has(system.id) && !bundledIds.has(system.id));
+  const systems: Array<DesignSystem & { originDir: string }> = [
+    ...bundled.map((system) => ({ ...system, originDir: systemsDir })),
+    ...library.map((system) => ({ ...system, originDir: librarySystemsDir })),
+  ];
+  let document: string;
+  try {
+    document = deps.readFile(documentPath, 'utf8');
+  } catch {
+    return { ok: false, reason: 'cannot-read', documentPath };
+  }
+  if (!directions.some((direction) => direction.id === directionId)) {
+    return { ok: false, reason: 'unknown-direction', documentPath, availableDirections: directions.map((direction) => direction.id) };
+  }
+
+  const system = systems.find((candidate) => candidate.id === directionId);
+  try {
+    if (!system) {
+      deps.writeFile(documentPath, writeDeclaredDirection(document, directionId));
+    } else {
+      // A partial virtual filesystem must not silently mutate the live filesystem.
+      if (filesystemKeys.some((key) => overrides[key] !== undefined)
+        && filesystemKeys.some((key) => overrides[key] === undefined)) {
+        throw new Error('design-system filesystem dependencies must be supplied together');
+      }
+      const source = join(system.originDir, system.id);
+      const destination = join(dirname(documentPath), 'design', 'system');
+      const files = [
+        { path: join(destination, 'DESIGN.md'), content: deps.readFile(join(source, 'DESIGN.md'), 'utf8') },
+        { path: join(destination, 'tokens.css'), content: deps.readFile(join(source, 'tokens.css'), 'utf8') },
+      ];
+      // Switching systems: a file that is byte-for-byte the CURRENTLY declared
+      // system's vendored copy was written by us and never edited, so it may be
+      // replaced. Anything else is a human's file and still blocks.
+      const declared = parseDeclaredDirection(document, directions).declared;
+      const declaredSystem = declared && declared !== system.id ? systems.find((candidate) => candidate.id === declared) : undefined;
+      const readDeclared = (name: string): string | null => {
+        if (!declaredSystem) return null;
+        try { return deps.readFile(join(declaredSystem.originDir, declaredSystem.id, name), 'utf8'); } catch { return null; }
+      };
+      const absent: typeof files = [];
+      const replaced: Array<{ path: string; content: string; previous: string }> = [];
+      for (const file of files) {
+        let existing: string;
+        try {
+          existing = deps.readFile(file.path, 'utf8');
+        } catch (error) {
+          if (!hasCode(error, 'ENOENT')) throw error;
+          absent.push(file);
+          continue;
+        }
+        if (existing === file.content) continue;
+        if (existing === readDeclared(file.path.slice(destination.length + 1))) {
+          replaced.push({ ...file, previous: existing });
+          continue;
+        }
+        return { ok: false, reason: 'conflicting-system-file', documentPath, path: file.path };
+      }
+      const createdDirs: string[] = [];
+      const createdFiles: string[] = [];
+      const restored: typeof replaced = [];
+      let temporaryDocument: string | undefined;
+      let failedPath: string | undefined;
+      const ensureDir = (path: string) => {
+        try {
+          deps.readdir(path);
+        } catch (error) {
+          if (!hasCode(error, 'ENOENT')) throw error;
+          deps.mkdir(path);
+          createdDirs.push(path);
+        }
+      };
+      try {
+        if (absent.length) {
+          ensureDir(dirname(destination));
+          ensureDir(destination);
+          for (const file of absent) {
+            try {
+              deps.writeFile(file.path, file.content, { exclusive: true, onCreated: () => { createdFiles.push(file.path); } });
+            } catch (error) {
+              if (hasCode(error, 'EEXIST')) failedPath = file.path;
+              throw error;
+            }
+          }
+        }
+        for (const file of replaced) {
+          deps.writeFile(file.path, file.content);
+          restored.push(file);
+        }
+        const virtualIo = filesystemKeys.some((key) => overrides[key] !== undefined);
+        const target = (overrides.documentTarget ?? (virtualIo ? (path: string): { path: string; mode?: number } => ({ path }) : liveDeps.documentTarget))(documentPath);
+        const setMode = overrides.setFileMode ?? (virtualIo ? () => {} : liveDeps.setFileMode);
+        const staged = `${target.path}.${randomUUID()}.tmp`;
+        deps.writeFile(staged, writeDeclaredSystemDirection(document, directionId, system.sourceCommit), {
+          exclusive: true, onCreated: () => { temporaryDocument = staged; },
+        });
+        if (target.mode !== undefined) setMode(staged, target.mode);
+        deps.renameFile(staged, target.path);
+        temporaryDocument = undefined;
+      } catch (error) {
+        if (temporaryDocument) {
+          try { deps.removeFile(temporaryDocument); } catch (cleanupError) {
+            if (!hasCode(cleanupError, 'ENOENT')) debug.log('repo-design-direction', 'rollback-failed', { path: temporaryDocument, error: String(cleanupError) }, { level: 'error' });
+          }
+        }
+        for (const file of restored.reverse()) {
+          try { deps.writeFile(file.path, file.previous); } catch (cleanupError) {
+            debug.log('repo-design-direction', 'rollback-failed', { path: file.path, error: String(cleanupError) }, { level: 'error' });
+          }
+        }
+        for (const path of createdFiles.reverse()) {
+          try { deps.removeFile(path); } catch (cleanupError) {
+            if (!hasCode(cleanupError, 'ENOENT')) debug.log('repo-design-direction', 'rollback-failed', { path, error: String(cleanupError) }, { level: 'error' });
+          }
+        }
+        for (const path of createdDirs.reverse()) {
+          try { deps.removeDir(path); } catch (cleanupError) {
+            debug.log('repo-design-direction', 'rollback-failed', { path, error: String(cleanupError) }, { level: 'error' });
+          }
+        }
+        if (failedPath) return { ok: false, reason: 'conflicting-system-file', documentPath, path: failedPath };
+        throw error;
+      }
+    }
+  } catch (error) {
+    debug.log('repo-design-direction', 'write-failed', { documentPath, error: String(error) }, { level: 'error' });
+    return { ok: false, reason: 'cannot-write', documentPath };
+  }
+  return { ok: true, documentPath, direction: directionId };
+}

package/src/design/css-root-tokens.ts

@@ -0,0 +1,89 @@
+import type { DeclaredToken } from './design-tokens.js';
+
+export interface CssRootTokens {
+  readonly palette: readonly DeclaredToken[];
+  readonly typography: readonly DeclaredToken[];
+  readonly motion: readonly DeclaredToken[];
+  readonly other: readonly DeclaredToken[];
+}
+
+/** Only the first :root rule contributes tokens; selectors and comments are not declarations. */
+export function readCssRootTokens(css: string): CssRootTokens {
+  const result: {
+    palette: DeclaredToken[];
+    typography: DeclaredToken[];
+    motion: DeclaredToken[];
+    other: DeclaredToken[];
+  } = { palette: [], typography: [], motion: [], other: [] };
+
+  // Mask comments and strings without shifting indices, then inspect rule preludes only.
+  const masked = css.replace(/\/\*[\s\S]*?\*\/|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/g, (part) => ' '.repeat(part.length));
+  const frames = [{ ruleList: true, start: 0 }];
+  let opening = -1;
+  let parentheses = 0;
+  for (let i = 0; i < masked.length; i++) {
+    const c = masked[i];
+    if (c === '\\' && i + 1 < masked.length) { i++; continue; }
+    if (c === '(') { parentheses++; continue; }
+    if (c === ')') { parentheses = Math.max(0, parentheses - 1); continue; }
+    if (parentheses > 0) continue;
+    const frame = frames[frames.length - 1];
+    if (c === '{') {
+      const prelude = masked.slice(frame.start, i).trim();
+      if (frame.ruleList && /(?:^|,)\s*:root\s*(?=,|$)/.test(prelude)) { opening = i; break; }
+      frames.push({ ruleList: frame.ruleList && /^@(?:media|supports|container|layer|scope|document)\b/.test(prelude), start: i + 1 });
+    } else if (c === '}') {
+      if (frames.length > 1) frames.pop();
+      frames[frames.length - 1].start = i + 1;
+    } else if (c === ';') {
+      frame.start = i + 1;
+    }
+  }
+  if (opening < 0) return result;
+
+  // Walk the rule rather than stopping at the first brace inside a quoted or nested value.
+  let depth = 1;
+  let quote = '';
+  let comment = false;
+  let value = '';
+  let parens = 0;
+  const add = (declaration: string) => {
+    const match = /^\s*(--[\w\u0080-\uffff-]+)\s*:\s*([\s\S]*)$/.exec(declaration);
+    if (!match) return;
+    const token: DeclaredToken = { name: match[1], value: match[2].trim() };
+    const name = token.name.toLowerCase();
+    if (/^(?:#[\da-f]{3,8}\b|(?:rgb|hsl|oklch|lab|lch|color)\()/i.test(token.value)
+      || /^--(?:color|colour|accent|ink|ground|background|foreground|brand|surface|border|muted|bg|fg|primary|secondary)(?:-|_|$)/.test(name)) result.palette.push(token);
+    else if (/^--(?:font|typography|type|text|line-height|letter-spacing)(?:-|_|$)/.test(name)) result.typography.push(token);
+    else if (/^--(?:motion|duration|ease|easing|transition|animation|delay)(?:-|_|$)/.test(name)) result.motion.push(token);
+    else result.other.push(token);
+  };
+  for (let i = opening + 1; i < css.length && depth > 0; i++) {
+    const c = css[i];
+    const next = css[i + 1];
+    if (comment) {
+      if (c === '*' && next === '/') { comment = false; i++; }
+      else if (c === '\n') value += ' ';
+      continue;
+    }
+    if (quote) {
+      value += c;
+      if (c === '\\' && next !== undefined) value += css[++i];
+      else if (c === quote) quote = '';
+      continue;
+    }
+    if (c === '/' && next === '*') { comment = true; i++; value += ' '; continue; }
+    if (c === '\\' && next !== undefined) { value += c; value += next; i++; continue; }
+    if (c === '"' || c === "'") { quote = c; value += c; continue; }
+    if (c === '(') parens++;
+    else if (c === ')' && parens > 0) parens--;
+    if (parens === 0 && c === '{') depth++;
+    if (parens === 0 && c === '}') {
+      depth--;
+      if (depth === 0) { add(value); break; }
+    }
+    if (depth === 1 && parens === 0 && c === ';') { add(value); value = ''; }
+    else if (depth > 0) value += c;
+  }
+  return result;
+}

package/src/design/custom-system-create.ts

@@ -0,0 +1,230 @@
+// CLI 와 POST /v1/design-system 이 같이 부르는 한 곳.
+// 추출·승격·저장은 기존 모듈을 부르기만 한다. 못 읽은 토큰 값은 지어내지 않는다.
+
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { libraryDir, reservedDesignIds, saveCustomSystem } from './design-library.js';
+import { defaultDesignSystemsDir } from './design-systems.js';
+import {
+  promoteExtractToSystem,
+  promotePaletteToSystem,
+  type ExtractTokensJson,
+  type PromotedSystem,
+} from './system-from-extract.js';
+import type { ExtractDesignOptions, ExtractDesignResult } from '../webclone/extract-design-run.js';
+
+const ID_PATTERN = /^[a-z0-9-]+$/;
+const UNREAD_MARK = '원본에서 못 읽었다';
+
+export interface CustomSystemToken {
+  readonly token: string;
+  readonly value: string;
+  readonly from: string;
+}
+
+export interface CustomSystemCreated {
+  readonly ok: true;
+  readonly id: string;
+  readonly dir: string;
+  readonly tokens: readonly CustomSystemToken[];
+  readonly unread: number;
+  readonly warnings: readonly string[];
+  readonly extractDir?: string;
+  readonly system: PromotedSystem;
+}
+
+export interface CustomSystemRefused {
+  readonly ok: false;
+  readonly reason: 'bad-url' | 'bad-id' | 'id-taken' | 'extract-failed' | 'no-colors';
+  readonly detail?: string;
+}
+
+export type CustomSystemCreateResult = CustomSystemCreated | CustomSystemRefused;
+
+export interface CreateCustomSystemFromUrlInput {
+  readonly url: string;
+  readonly id?: string;
+  readonly name?: string;
+  readonly base?: string;
+  readonly out?: string;
+}
+
+export interface CreateCustomSystemFromPaletteInput {
+  readonly colors: readonly string[];
+  readonly id: string;
+  readonly name?: string;
+  readonly base?: string;
+}
+
+export interface CustomSystemCreateDeps {
+  readonly libraryDirectory?: () => string;
+  readonly systemsDirectory?: () => string;
+  readonly extractRoot?: () => string;
+  readonly readFile?: (path: string, encoding: 'utf8') => string;
+  readonly runExtractDesign?: (options: ExtractDesignOptions) => Promise<ExtractDesignResult>;
+  readonly promoteExtract?: typeof promoteExtractToSystem;
+  readonly promotePalette?: typeof promotePaletteToSystem;
+  readonly save?: typeof saveCustomSystem;
+  readonly reservedIds?: (systemsDir: string) => ReadonlySet<string>;
+  readonly takenIds?: (libraryDir: string) => ReadonlySet<string>;
+}
+
+export function hostSlugFromUrl(url: string): string | null {
+  let parsed: URL;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return null;
+  }
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return null;
+  const host = parsed.hostname.replace(/^www\./i, '').split('.')[0] ?? '';
+  const slug = host.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+  return slug || null;
+}
+
+export function unreadTokenCount(tokensCss: string): number {
+  return tokensCss.split('\n').filter((line) => line.includes(UNREAD_MARK)).length;
+}
+
+function defaultTakenIds(dir: string): ReadonlySet<string> {
+  if (!existsSync(dir)) return new Set();
+  try {
+    return new Set(
+      readdirSync(dir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name),
+    );
+  } catch {
+    return new Set();
+  }
+}
+
+function allocateId(
+  requested: string | undefined,
+  fallback: string | null,
+  taken: ReadonlySet<string>,
+  reserved: ReadonlySet<string>,
+): { id: string } | CustomSystemRefused {
+  const raw = requested?.trim() || fallback || '';
+  if (!raw || !ID_PATTERN.test(raw)) return { ok: false, reason: 'bad-id', detail: raw || undefined };
+  if (requested?.trim()) {
+    if (taken.has(raw) || reserved.has(raw)) return { ok: false, reason: 'id-taken', detail: raw };
+    return { id: raw };
+  }
+  if (!taken.has(raw) && !reserved.has(raw)) return { id: raw };
+  for (let n = 2; n < 10_000; n += 1) {
+    const next = `${raw}-${n}`;
+    if (!taken.has(next) && !reserved.has(next)) return { id: next };
+  }
+  return { ok: false, reason: 'id-taken', detail: raw };
+}
+
+function created(system: PromotedSystem, dir: string, extractDir?: string): CustomSystemCreated {
+  return {
+    ok: true,
+    id: system.manifest.id,
+    dir,
+    tokens: system.provenance.map((row) => ({ token: row.token, value: row.value, from: row.from })),
+    unread: unreadTokenCount(system.tokensCss),
+    warnings: system.warnings,
+    ...(extractDir === undefined ? {} : { extractDir }),
+    system,
+  };
+}
+
+function refusalFromSave(error: unknown, id: string): CustomSystemRefused {
+  const detail = error instanceof Error ? error.message : String(error);
+  if (detail.includes('겹친다') || detail.includes('id 거부') || detail.includes('EEXIST')) {
+    return { ok: false, reason: 'id-taken', detail: id };
+  }
+  return { ok: false, reason: 'extract-failed', detail };
+}
+
+export async function createCustomSystemFromUrl(
+  input: CreateCustomSystemFromUrlInput,
+  deps: CustomSystemCreateDeps = {},
+): Promise<CustomSystemCreateResult> {
+  const url = input.url.trim();
+  const slug = hostSlugFromUrl(url);
+  if (!slug) return { ok: false, reason: 'bad-url', detail: url || undefined };
+
+  const systemsDir = (deps.systemsDirectory ?? defaultDesignSystemsDir)();
+  const library = (deps.libraryDirectory ?? libraryDir)();
+  const reserved = (deps.reservedIds ?? reservedDesignIds)(systemsDir);
+  const taken = (deps.takenIds ?? defaultTakenIds)(library);
+  const allocated = allocateId(input.id, slug, taken, reserved);
+  if ('ok' in allocated) return allocated;
+
+  const outRoot = input.out ?? (deps.extractRoot ?? (() => join(elanousStateRoot(), 'design', 'extracts')))();
+  const extract = deps.runExtractDesign ?? (await import('../webclone/extract-design-run.js')).runExtractDesign;
+  let extracted: ExtractDesignResult;
+  try {
+    extracted = await extract({ url, outRoot, withAssets: false });
+  } catch (error) {
+    return { ok: false, reason: 'extract-failed', detail: error instanceof Error ? error.message : String(error) };
+  }
+
+  const readFile = deps.readFile ?? ((path: string) => readFileSync(path, 'utf8'));
+  let tokens: ExtractTokensJson;
+  try {
+    tokens = JSON.parse(readFile(join(extracted.outDir, 'tokens.json'), 'utf8')) as ExtractTokensJson;
+  } catch (error) {
+    return { ok: false, reason: 'extract-failed', detail: error instanceof Error ? error.message : String(error) };
+  }
+
+  const promote = deps.promoteExtract ?? promoteExtractToSystem;
+  const name = input.name?.trim() || allocated.id;
+  let system: PromotedSystem;
+  try {
+    system = promote(tokens, {
+      id: allocated.id,
+      name,
+      sourceUrl: url,
+      base: input.base,
+      systemsDir,
+    });
+  } catch (error) {
+    return { ok: false, reason: 'extract-failed', detail: error instanceof Error ? error.message : String(error) };
+  }
+
+  try {
+    const saved = (deps.save ?? saveCustomSystem)(library, system, { systemsDir });
+    return created(system, saved.dir, extracted.outDir);
+  } catch (error) {
+    return refusalFromSave(error, allocated.id);
+  }
+}
+
+export async function createCustomSystemFromPalette(
+  input: CreateCustomSystemFromPaletteInput,
+  deps: CustomSystemCreateDeps = {},
+): Promise<CustomSystemCreateResult> {
+  const colors = input.colors.map((color) => color.trim()).filter(Boolean);
+  if (colors.length === 0) return { ok: false, reason: 'no-colors' };
+
+  const systemsDir = (deps.systemsDirectory ?? defaultDesignSystemsDir)();
+  const library = (deps.libraryDirectory ?? libraryDir)();
+  const reserved = (deps.reservedIds ?? reservedDesignIds)(systemsDir);
+  const taken = (deps.takenIds ?? defaultTakenIds)(library);
+  const allocated = allocateId(input.id, null, taken, reserved);
+  if ('ok' in allocated) return allocated;
+
+  const promote = deps.promotePalette ?? promotePaletteToSystem;
+  const name = input.name?.trim() || allocated.id;
+  let system: PromotedSystem;
+  try {
+    system = promote(colors, { id: allocated.id, name, base: input.base, systemsDir });
+  } catch (error) {
+    return { ok: false, reason: 'no-colors', detail: error instanceof Error ? error.message : String(error) };
+  }
+  if (system.provenance.length === 0) return { ok: false, reason: 'no-colors' };
+
+  try {
+    const saved = (deps.save ?? saveCustomSystem)(library, system, { systemsDir });
+    return created(system, saved.dir);
+  } catch (error) {
+    return refusalFromSave(error, allocated.id);
+  }
+}