From b5d5956ff7758a364671a2099eb20c5ab92ffa9e Mon Sep 17 00:00:00 2001 From: Pedro Mendes Date: Tue, 19 May 2026 11:02:05 -0300 Subject: [PATCH 01/13] chore: package local supipowers updates --- .../cross-platform-compatibility/SKILL.md | 108 + .../references/build-configuration.md | 31 + .../references/character-encoding.md | 58 + .../references/environment-variables.md | 43 + .../references/file-path-handling.md | 93 + .../references/file-permissions.md | 43 + .../references/line-endings.md | 43 + .../references/platform-detection.md | 113 + .../platform-specific-dependencies.md | 48 + .../references/process-management.md | 54 + .../references/shell-commands.md | 60 + .../references/testing-across-platforms.md | 88 + .../scripts/scaffold-tests.sh | 18 + .../templates/test-template.js | 27 + .agents/skills/impeccable/SKILL.md | 163 + .agents/skills/impeccable/agents/openai.yaml | 4 + .agents/skills/impeccable/reference/adapt.md | 190 + .../skills/impeccable/reference/animate.md | 175 + .agents/skills/impeccable/reference/audit.md | 133 + .agents/skills/impeccable/reference/bolder.md | 113 + .agents/skills/impeccable/reference/brand.md | 118 + .../skills/impeccable/reference/clarify.md | 174 + .agents/skills/impeccable/reference/codex.md | 105 + .../impeccable/reference/cognitive-load.md | 106 + .../reference/color-and-contrast.md | 105 + .../skills/impeccable/reference/colorize.md | 154 + .agents/skills/impeccable/reference/craft.md | 123 + .../skills/impeccable/reference/critique.md | 259 + .../skills/impeccable/reference/delight.md | 302 + .../skills/impeccable/reference/distill.md | 111 + .../skills/impeccable/reference/document.md | 427 ++ .../skills/impeccable/reference/extract.md | 69 + .agents/skills/impeccable/reference/harden.md | 347 ++ .../reference/heuristics-scoring.md | 234 + .../reference/interaction-design.md | 195 + .agents/skills/impeccable/reference/layout.md | 141 + .agents/skills/impeccable/reference/live.md | 622 +++ .../impeccable/reference/motion-design.md | 109 + .../skills/impeccable/reference/onboard.md | 234 + .../skills/impeccable/reference/optimize.md | 258 + .../skills/impeccable/reference/overdrive.md | 130 + .../skills/impeccable/reference/personas.md | 179 + .agents/skills/impeccable/reference/polish.md | 242 + .../skills/impeccable/reference/product.md | 62 + .../skills/impeccable/reference/quieter.md | 99 + .../impeccable/reference/responsive-design.md | 114 + .agents/skills/impeccable/reference/shape.md | 165 + .../impeccable/reference/spatial-design.md | 100 + .agents/skills/impeccable/reference/teach.md | 156 + .../skills/impeccable/reference/typeset.md | 124 + .../skills/impeccable/reference/typography.md | 159 + .../skills/impeccable/reference/ux-writing.md | 107 + .../impeccable/scripts/cleanup-deprecated.mjs | 284 + .../impeccable/scripts/command-metadata.json | 94 + .../impeccable/scripts/critique-storage.mjs | 242 + .../impeccable/scripts/design-parser.mjs | 820 +++ .../skills/impeccable/scripts/detect-csp.mjs | 198 + .agents/skills/impeccable/scripts/detect.mjs | 21 + .../detector/browser/injected/index.mjs | 1688 ++++++ .../impeccable/scripts/detector/cli/main.mjs | 232 + .../detector/detect-antipatterns-browser.js | 4030 ++++++++++++++ .../scripts/detector/detect-antipatterns.mjs | 43 + .../detector/engines/browser/detect-url.mjs | 251 + .../detector/engines/regex/detect-text.mjs | 420 ++ .../engines/static-html/css-cascade.mjs | 954 ++++ .../engines/static-html/detect-html.mjs | 174 + .../engines/visual/screenshot-contrast.mjs | 189 + .../impeccable/scripts/detector/findings.mjs | 12 + .../scripts/detector/node/file-system.mjs | 198 + .../scripts/detector/profile/profiler.mjs | 166 + .../detector/registry/antipatterns.mjs | 278 + .../scripts/detector/rules/checks.mjs | 1948 +++++++ .../scripts/detector/shared/color.mjs | 124 + .../scripts/detector/shared/constants.mjs | 101 + .../scripts/detector/shared/page.mjs | 7 + .../impeccable/scripts/impeccable-paths.mjs | 110 + .../impeccable/scripts/is-generated.mjs | 69 + .../skills/impeccable/scripts/live-accept.mjs | 595 ++ .../scripts/live-browser-session.js | 123 + .../skills/impeccable/scripts/live-browser.js | 4860 +++++++++++++++++ .../impeccable/scripts/live-complete.mjs | 75 + .../impeccable/scripts/live-completion.mjs | 18 + .../skills/impeccable/scripts/live-inject.mjs | 446 ++ .../skills/impeccable/scripts/live-poll.mjs | 200 + .../skills/impeccable/scripts/live-resume.mjs | 48 + .../skills/impeccable/scripts/live-server.mjs | 838 +++ .../impeccable/scripts/live-session-store.mjs | 254 + .../skills/impeccable/scripts/live-status.mjs | 47 + .../skills/impeccable/scripts/live-wrap.mjs | 632 +++ .agents/skills/impeccable/scripts/live.mjs | 247 + .../impeccable/scripts/load-context.mjs | 141 + .../scripts/modern-screenshot.umd.js | 14 + .agents/skills/impeccable/scripts/pin.mjs | 214 + .github/workflows/ci.yml | 11 +- package.json | 3 +- skills-lock.json | 11 + src/ci.ts | 47 + src/commands/memory.ts | 143 +- src/config/defaults.ts | 2 + src/config/schema.ts | 2 + src/context-mode/sandbox/executor.ts | 19 +- src/fix-pr/scripts/exec.ts | 33 +- src/harness/stages/implement-apply.ts | 1 + src/harness/storage.ts | 3 +- src/mempalace/contract.ts | 32 + src/mempalace/git-hook.ts | 432 ++ src/mempalace/hooks.ts | 25 +- src/mempalace/tool.ts | 4 +- src/mempalace/uv.ts | 37 +- src/storage/plans.ts | 4 +- src/text.ts | 9 +- src/types.ts | 2 + src/utils/editor.ts | 36 +- tests/commands/memory.test.ts | 4 +- tests/context-mode/sandbox/executor.test.ts | 20 +- tests/fix-pr/scripts/exec.test.ts | 33 + tests/harness/stages/implement-apply.test.ts | 1 + tests/harness/storage.test.ts | 15 +- tests/mempalace/config.test.ts | 2 + tests/mempalace/git-hook.test.ts | 212 + tests/mempalace/hooks.test.ts | 37 +- tests/mempalace/tool.test.ts | 1 + tests/mempalace/uv.test.ts | 34 +- tests/platform/ci-matrix.test.ts | 69 + tests/platform/ci-plan.test.ts | 26 + tests/platform/context-storage-smoke.test.ts | 103 + tests/platform/paths.test.ts | 138 + tests/platform/static-hazards.test.ts | 97 + tests/storage/plan-artifacts.test.ts | 34 + tests/text.test.ts | 16 +- tests/utils/editor.test.ts | 81 + 131 files changed, 30568 insertions(+), 51 deletions(-) create mode 100644 .agents/skills/cross-platform-compatibility/SKILL.md create mode 100644 .agents/skills/cross-platform-compatibility/references/build-configuration.md create mode 100644 .agents/skills/cross-platform-compatibility/references/character-encoding.md create mode 100644 .agents/skills/cross-platform-compatibility/references/environment-variables.md create mode 100644 .agents/skills/cross-platform-compatibility/references/file-path-handling.md create mode 100644 .agents/skills/cross-platform-compatibility/references/file-permissions.md create mode 100644 .agents/skills/cross-platform-compatibility/references/line-endings.md create mode 100644 .agents/skills/cross-platform-compatibility/references/platform-detection.md create mode 100644 .agents/skills/cross-platform-compatibility/references/platform-specific-dependencies.md create mode 100644 .agents/skills/cross-platform-compatibility/references/process-management.md create mode 100644 .agents/skills/cross-platform-compatibility/references/shell-commands.md create mode 100644 .agents/skills/cross-platform-compatibility/references/testing-across-platforms.md create mode 100755 .agents/skills/cross-platform-compatibility/scripts/scaffold-tests.sh create mode 100644 .agents/skills/cross-platform-compatibility/templates/test-template.js create mode 100644 .agents/skills/impeccable/SKILL.md create mode 100644 .agents/skills/impeccable/agents/openai.yaml create mode 100644 .agents/skills/impeccable/reference/adapt.md create mode 100644 .agents/skills/impeccable/reference/animate.md create mode 100644 .agents/skills/impeccable/reference/audit.md create mode 100644 .agents/skills/impeccable/reference/bolder.md create mode 100644 .agents/skills/impeccable/reference/brand.md create mode 100644 .agents/skills/impeccable/reference/clarify.md create mode 100644 .agents/skills/impeccable/reference/codex.md create mode 100644 .agents/skills/impeccable/reference/cognitive-load.md create mode 100644 .agents/skills/impeccable/reference/color-and-contrast.md create mode 100644 .agents/skills/impeccable/reference/colorize.md create mode 100644 .agents/skills/impeccable/reference/craft.md create mode 100644 .agents/skills/impeccable/reference/critique.md create mode 100644 .agents/skills/impeccable/reference/delight.md create mode 100644 .agents/skills/impeccable/reference/distill.md create mode 100644 .agents/skills/impeccable/reference/document.md create mode 100644 .agents/skills/impeccable/reference/extract.md create mode 100644 .agents/skills/impeccable/reference/harden.md create mode 100644 .agents/skills/impeccable/reference/heuristics-scoring.md create mode 100644 .agents/skills/impeccable/reference/interaction-design.md create mode 100644 .agents/skills/impeccable/reference/layout.md create mode 100644 .agents/skills/impeccable/reference/live.md create mode 100644 .agents/skills/impeccable/reference/motion-design.md create mode 100644 .agents/skills/impeccable/reference/onboard.md create mode 100644 .agents/skills/impeccable/reference/optimize.md create mode 100644 .agents/skills/impeccable/reference/overdrive.md create mode 100644 .agents/skills/impeccable/reference/personas.md create mode 100644 .agents/skills/impeccable/reference/polish.md create mode 100644 .agents/skills/impeccable/reference/product.md create mode 100644 .agents/skills/impeccable/reference/quieter.md create mode 100644 .agents/skills/impeccable/reference/responsive-design.md create mode 100644 .agents/skills/impeccable/reference/shape.md create mode 100644 .agents/skills/impeccable/reference/spatial-design.md create mode 100644 .agents/skills/impeccable/reference/teach.md create mode 100644 .agents/skills/impeccable/reference/typeset.md create mode 100644 .agents/skills/impeccable/reference/typography.md create mode 100644 .agents/skills/impeccable/reference/ux-writing.md create mode 100644 .agents/skills/impeccable/scripts/cleanup-deprecated.mjs create mode 100644 .agents/skills/impeccable/scripts/command-metadata.json create mode 100644 .agents/skills/impeccable/scripts/critique-storage.mjs create mode 100644 .agents/skills/impeccable/scripts/design-parser.mjs create mode 100644 .agents/skills/impeccable/scripts/detect-csp.mjs create mode 100644 .agents/skills/impeccable/scripts/detect.mjs create mode 100644 .agents/skills/impeccable/scripts/detector/browser/injected/index.mjs create mode 100644 .agents/skills/impeccable/scripts/detector/cli/main.mjs create mode 100644 .agents/skills/impeccable/scripts/detector/detect-antipatterns-browser.js create mode 100644 .agents/skills/impeccable/scripts/detector/detect-antipatterns.mjs create mode 100644 .agents/skills/impeccable/scripts/detector/engines/browser/detect-url.mjs create mode 100644 .agents/skills/impeccable/scripts/detector/engines/regex/detect-text.mjs create mode 100644 .agents/skills/impeccable/scripts/detector/engines/static-html/css-cascade.mjs create mode 100644 .agents/skills/impeccable/scripts/detector/engines/static-html/detect-html.mjs create mode 100644 .agents/skills/impeccable/scripts/detector/engines/visual/screenshot-contrast.mjs create mode 100644 .agents/skills/impeccable/scripts/detector/findings.mjs create mode 100644 .agents/skills/impeccable/scripts/detector/node/file-system.mjs create mode 100644 .agents/skills/impeccable/scripts/detector/profile/profiler.mjs create mode 100644 .agents/skills/impeccable/scripts/detector/registry/antipatterns.mjs create mode 100644 .agents/skills/impeccable/scripts/detector/rules/checks.mjs create mode 100644 .agents/skills/impeccable/scripts/detector/shared/color.mjs create mode 100644 .agents/skills/impeccable/scripts/detector/shared/constants.mjs create mode 100644 .agents/skills/impeccable/scripts/detector/shared/page.mjs create mode 100644 .agents/skills/impeccable/scripts/impeccable-paths.mjs create mode 100644 .agents/skills/impeccable/scripts/is-generated.mjs create mode 100644 .agents/skills/impeccable/scripts/live-accept.mjs create mode 100644 .agents/skills/impeccable/scripts/live-browser-session.js create mode 100644 .agents/skills/impeccable/scripts/live-browser.js create mode 100644 .agents/skills/impeccable/scripts/live-complete.mjs create mode 100644 .agents/skills/impeccable/scripts/live-completion.mjs create mode 100644 .agents/skills/impeccable/scripts/live-inject.mjs create mode 100644 .agents/skills/impeccable/scripts/live-poll.mjs create mode 100644 .agents/skills/impeccable/scripts/live-resume.mjs create mode 100644 .agents/skills/impeccable/scripts/live-server.mjs create mode 100644 .agents/skills/impeccable/scripts/live-session-store.mjs create mode 100644 .agents/skills/impeccable/scripts/live-status.mjs create mode 100644 .agents/skills/impeccable/scripts/live-wrap.mjs create mode 100644 .agents/skills/impeccable/scripts/live.mjs create mode 100644 .agents/skills/impeccable/scripts/load-context.mjs create mode 100644 .agents/skills/impeccable/scripts/modern-screenshot.umd.js create mode 100644 .agents/skills/impeccable/scripts/pin.mjs create mode 100644 skills-lock.json create mode 100644 src/ci.ts create mode 100644 src/mempalace/contract.ts create mode 100644 src/mempalace/git-hook.ts create mode 100644 tests/fix-pr/scripts/exec.test.ts create mode 100644 tests/mempalace/git-hook.test.ts create mode 100644 tests/platform/ci-matrix.test.ts create mode 100644 tests/platform/ci-plan.test.ts create mode 100644 tests/platform/context-storage-smoke.test.ts create mode 100644 tests/platform/paths.test.ts create mode 100644 tests/platform/static-hazards.test.ts create mode 100644 tests/storage/plan-artifacts.test.ts create mode 100644 tests/utils/editor.test.ts diff --git a/.agents/skills/cross-platform-compatibility/SKILL.md b/.agents/skills/cross-platform-compatibility/SKILL.md new file mode 100644 index 00000000..2e8b753e --- /dev/null +++ b/.agents/skills/cross-platform-compatibility/SKILL.md @@ -0,0 +1,108 @@ +--- +name: cross-platform-compatibility +description: > + Handle cross-platform compatibility including file paths, environment + detection, platform-specific dependencies, and testing across Windows, macOS, + and Linux. Use when dealing with platform-specific code or OS compatibility. +--- + +# Cross-Platform Compatibility + +## Table of Contents + +- [Overview](#overview) +- [When to Use](#when-to-use) +- [Quick Start](#quick-start) +- [Reference Guides](#reference-guides) +- [Best Practices](#best-practices) + +## Overview + +Comprehensive guide to writing code that works seamlessly across Windows, macOS, and Linux. Covers file path handling, environment detection, platform-specific features, and testing strategies. + +## When to Use + +- Building applications for multiple operating systems +- Handling file system operations +- Managing platform-specific dependencies +- Detecting operating system and architecture +- Working with environment variables +- Building cross-platform CLI tools +- Dealing with line endings and character encodings +- Managing platform-specific build processes + +## Quick Start + +Minimal working example: + +```typescript +// ❌ BAD: Hardcoded paths with platform-specific separators +const configPath = "C:\\Users\\user\\config.json"; // Windows only +const dataPath = "/home/user/data.txt"; // Unix only + +// ✅ GOOD: Use path module +import path from "path"; +import os from "os"; + +// Platform-independent path construction +const configPath = path.join(os.homedir(), "config", "app.json"); +const dataPath = path.join(process.cwd(), "data", "users.txt"); + +// Resolve relative paths +const absolutePath = path.resolve("./config/settings.json"); + +// Get path components +const dirname = path.dirname("/path/to/file.txt"); // '/path/to' +const basename = path.basename("/path/to/file.txt"); // 'file.txt' +const extname = path.extname("/path/to/file.txt"); // '.txt' + +// Normalize paths (handle .. and .) +const normalized = path.normalize("/path/to/../file.txt"); // '/path/file.txt' +``` + +## Reference Guides + +Detailed implementations in the `references/` directory: + +| Guide | Contents | +|---|---| +| [File Path Handling](references/file-path-handling.md) | File Path Handling | +| [Platform Detection](references/platform-detection.md) | Platform Detection | +| [Line Endings](references/line-endings.md) | Line Endings | +| [Environment Variables](references/environment-variables.md) | Environment Variables | +| [Shell Commands](references/shell-commands.md) | Shell Commands | +| [File Permissions](references/file-permissions.md) | File Permissions | +| [Process Management](references/process-management.md) | Process Management | +| [Platform-Specific Dependencies](references/platform-specific-dependencies.md) | Platform-Specific Dependencies | +| [Testing Across Platforms](references/testing-across-platforms.md) | Testing Across Platforms | +| [Character Encoding](references/character-encoding.md) | Character Encoding | +| [Build Configuration](references/build-configuration.md) | Build Configuration | + +## Best Practices + +### ✅ DO + +- Use path.join() or path.resolve() for paths +- Use os.EOL for line endings +- Detect platform at runtime when needed +- Test on all target platforms +- Use optionalDependencies for platform-specific modules +- Handle file permissions gracefully +- Use shell escaping for user input +- Normalize line endings in text files +- Use UTF-8 encoding by default +- Document platform-specific behavior +- Provide fallbacks for platform-specific features +- Use CI/CD to test on multiple platforms + +### ❌ DON'T + +- Hardcode file paths with backslashes or forward slashes +- Assume Unix-only features (signals, permissions, symlinks) +- Ignore Windows-specific quirks (drive letters, UNC paths) +- Use platform-specific commands without fallbacks +- Assume case-sensitive file systems +- Forget about different line endings +- Use platform-specific APIs without checking +- Hardcode environment variable access patterns +- Ignore character encoding issues diff --git a/.agents/skills/cross-platform-compatibility/references/build-configuration.md b/.agents/skills/cross-platform-compatibility/references/build-configuration.md new file mode 100644 index 00000000..2f9aa2bf --- /dev/null +++ b/.agents/skills/cross-platform-compatibility/references/build-configuration.md @@ -0,0 +1,31 @@ +# Build Configuration + +## Build Configuration + +```typescript +// rollup.config.js +export default { + input: "src/index.ts", + output: [ + { + file: "dist/index.js", + format: "cjs", + }, + { + file: "dist/index.esm.js", + format: "esm", + }, + ], + external: [ + // Mark platform-specific modules as external + "fsevents", + ], + plugins: [ + // Replace platform checks at build time for better tree-shaking + replace({ + "process.platform": JSON.stringify(process.platform), + preventAssignment: true, + }), + ], +}; +``` diff --git a/.agents/skills/cross-platform-compatibility/references/character-encoding.md b/.agents/skills/cross-platform-compatibility/references/character-encoding.md new file mode 100644 index 00000000..eb53e6e3 --- /dev/null +++ b/.agents/skills/cross-platform-compatibility/references/character-encoding.md @@ -0,0 +1,58 @@ +# Character Encoding + +## Character Encoding + +```typescript +// encoding-utils.ts +import iconv from "iconv-lite"; + +export class EncodingUtils { + // Read file with specific encoding + static readFile(filepath: string, encoding: string = "utf8"): string { + const buffer = fs.readFileSync(filepath); + + if (encoding === "utf8") { + // Remove BOM if present + if (buffer[0] === 0xef && buffer[1] === 0xbb && buffer[2] === 0xbf) { + return buffer.slice(3).toString("utf8"); + } + return buffer.toString("utf8"); + } + + return iconv.decode(buffer, encoding); + } + + // Write file with specific encoding + static writeFile( + filepath: string, + content: string, + encoding: string = "utf8", + ): void { + if (encoding === "utf8") { + fs.writeFileSync(filepath, content, "utf8"); + } else { + const buffer = iconv.encode(content, encoding); + fs.writeFileSync(filepath, buffer); + } + } + + // Detect encoding + static detectEncoding(filepath: string): string { + const buffer = fs.readFileSync(filepath); + + // Check for BOM + if (buffer[0] === 0xef && buffer[1] === 0xbb && buffer[2] === 0xbf) { + return "utf8"; + } + if (buffer[0] === 0xfe && buffer[1] === 0xff) { + return "utf16be"; + } + if (buffer[0] === 0xff && buffer[1] === 0xfe) { + return "utf16le"; + } + + // Default to UTF-8 + return "utf8"; + } +} +``` diff --git a/.agents/skills/cross-platform-compatibility/references/environment-variables.md b/.agents/skills/cross-platform-compatibility/references/environment-variables.md new file mode 100644 index 00000000..803d0778 --- /dev/null +++ b/.agents/skills/cross-platform-compatibility/references/environment-variables.md @@ -0,0 +1,43 @@ +# Environment Variables + +## Environment Variables + +```typescript +// env-utils.ts +export class EnvUtils { + // Get environment variable with fallback + static get(key: string, defaultValue?: string): string | undefined { + return process.env[key] || defaultValue; + } + + // Get PATH separator (: on Unix, ; on Windows) + static get pathSeparator(): string { + return process.platform === "win32" ? ";" : ":"; + } + + // Split PATH into array + static getPaths(): string[] { + const pathVar = process.env.PATH || ""; + return pathVar.split(this.pathSeparator); + } + + // Get common paths + static get home(): string { + return process.env.HOME || process.env.USERPROFILE || ""; + } + + static get user(): string { + return process.env.USER || process.env.USERNAME || ""; + } + + // Check if running in CI + static get isCI(): boolean { + return !!( + process.env.CI || + process.env.CONTINUOUS_INTEGRATION || + process.env.GITHUB_ACTIONS || + process.env.GITLAB_CI + ); + } +} +``` diff --git a/.agents/skills/cross-platform-compatibility/references/file-path-handling.md b/.agents/skills/cross-platform-compatibility/references/file-path-handling.md new file mode 100644 index 00000000..76a86904 --- /dev/null +++ b/.agents/skills/cross-platform-compatibility/references/file-path-handling.md @@ -0,0 +1,93 @@ +# File Path Handling + +## File Path Handling + +### Node.js Path Module + +```typescript +// ❌ BAD: Hardcoded paths with platform-specific separators +const configPath = "C:\\Users\\user\\config.json"; // Windows only +const dataPath = "/home/user/data.txt"; // Unix only + +// ✅ GOOD: Use path module +import path from "path"; +import os from "os"; + +// Platform-independent path construction +const configPath = path.join(os.homedir(), "config", "app.json"); +const dataPath = path.join(process.cwd(), "data", "users.txt"); + +// Resolve relative paths +const absolutePath = path.resolve("./config/settings.json"); + +// Get path components +const dirname = path.dirname("/path/to/file.txt"); // '/path/to' +const basename = path.basename("/path/to/file.txt"); // 'file.txt' +const extname = path.extname("/path/to/file.txt"); // '.txt' + +// Normalize paths (handle .. and .) +const normalized = path.normalize("/path/to/../file.txt"); // '/path/file.txt' +``` + +### Python Path Handling + +```python +# ❌ BAD: Hardcoded separators +config_path = 'C:\\Users\\user\\config.json' # Windows only +data_path = '/home/user/data.txt' # Unix only + +# ✅ GOOD: Use pathlib +from pathlib import Path +import os + +# Platform-independent path construction +config_path = Path.home() / 'config' / 'app.json' +data_path = Path.cwd() / 'data' / 'users.txt' + +# Working with paths +if config_path.exists(): + content = config_path.read_text() + +# Get path components +dirname = config_path.parent +filename = config_path.name +extension = config_path.suffix + +# Resolve relative paths +absolute_path = Path('./config/settings.json').resolve() + +# Create directories +output_dir = Path('output') +output_dir.mkdir(parents=True, exist_ok=True) +``` + +### Go Path Handling + +```go +package main + +import ( + "os" + "path/filepath" +) + +func main() { + // ❌ BAD: Hardcoded paths + // configPath := "C:\\Users\\user\\config.json" + + // ✅ GOOD: Use filepath package + homeDir, _ := os.UserHomeDir() + configPath := filepath.Join(homeDir, "config", "app.json") + + // Get path components + dir := filepath.Dir(configPath) + base := filepath.Base(configPath) + ext := filepath.Ext(configPath) + + // Clean and normalize paths + cleaned := filepath.Clean("path/to/../file.txt") + + // Convert to absolute path + absPath, _ := filepath.Abs("./config/settings.json") +} +``` diff --git a/.agents/skills/cross-platform-compatibility/references/file-permissions.md b/.agents/skills/cross-platform-compatibility/references/file-permissions.md new file mode 100644 index 00000000..1d063f8a --- /dev/null +++ b/.agents/skills/cross-platform-compatibility/references/file-permissions.md @@ -0,0 +1,43 @@ +# File Permissions + +## File Permissions + +```typescript +// permissions.ts +import fs from "fs"; +import path from "path"; + +export class FilePermissions { + // Make file executable (Unix only) + static makeExecutable(filepath: string): void { + if (process.platform !== "win32") { + fs.chmodSync(filepath, 0o755); + } + } + + // Check if file is executable + static isExecutable(filepath: string): boolean { + if (process.platform === "win32") { + // On Windows, check file extension + const ext = path.extname(filepath).toLowerCase(); + return [".exe", ".bat", ".cmd", ".com"].includes(ext); + } + + try { + fs.accessSync(filepath, fs.constants.X_OK); + return true; + } catch { + return false; + } + } + + // Create file with specific permissions (Unix) + static createWithPermissions( + filepath: string, + content: string, + mode: number = 0o644, + ): void { + fs.writeFileSync(filepath, content, { mode }); + } +} +``` diff --git a/.agents/skills/cross-platform-compatibility/references/line-endings.md b/.agents/skills/cross-platform-compatibility/references/line-endings.md new file mode 100644 index 00000000..d2eea72c --- /dev/null +++ b/.agents/skills/cross-platform-compatibility/references/line-endings.md @@ -0,0 +1,43 @@ +# Line Endings + +## Line Endings + +```typescript +// line-endings.ts +import os from "os"; + +export const LineEnding = { + LF: "\n", // Unix/Linux/macOS + CRLF: "\r\n", // Windows + CR: "\r", // Old Mac (pre-OS X) + + get platform(): string { + return os.EOL; // Returns platform-specific line ending + }, + + normalize(text: string, target: string = os.EOL): string { + // Normalize all line endings to target + return text.replace(/\r\n|\r|\n/g, target); + }, + + toUnix(text: string): string { + return this.normalize(text, this.LF); + }, + + toWindows(text: string): string { + return this.normalize(text, this.CRLF); + }, +}; + +// Usage +const fileContent = fs.readFileSync("file.txt", "utf8"); + +// Normalize to platform-specific line endings +const normalized = LineEnding.normalize(fileContent); + +// Force Unix line endings (for git, etc.) +const unixContent = LineEnding.toUnix(fileContent); + +// Write with platform-specific line endings +fs.writeFileSync("output.txt", normalized); +``` diff --git a/.agents/skills/cross-platform-compatibility/references/platform-detection.md b/.agents/skills/cross-platform-compatibility/references/platform-detection.md new file mode 100644 index 00000000..0ab9ff49 --- /dev/null +++ b/.agents/skills/cross-platform-compatibility/references/platform-detection.md @@ -0,0 +1,113 @@ +# Platform Detection + +## Platform Detection + +### Node.js Platform Detection + +```typescript +// platform-utils.ts +import os from "os"; + +export const Platform = { + isWindows: process.platform === "win32", + isMacOS: process.platform === "darwin", + isLinux: process.platform === "linux", + isUnix: process.platform !== "win32", + + get current(): "windows" | "macos" | "linux" | "unknown" { + switch (process.platform) { + case "win32": + return "windows"; + case "darwin": + return "macos"; + case "linux": + return "linux"; + default: + return "unknown"; + } + }, + + get arch(): string { + return process.arch; // 'x64', 'arm64', etc. + }, + + get homeDir(): string { + return os.homedir(); + }, + + get tempDir(): string { + return os.tmpdir(); + }, +}; + +// Usage +if (Platform.isWindows) { + // Windows-specific code + console.log("Running on Windows"); +} else if (Platform.isMacOS) { + // macOS-specific code + console.log("Running on macOS"); +} else if (Platform.isLinux) { + // Linux-specific code + console.log("Running on Linux"); +} + +// Architecture detection +if (Platform.arch === "arm64") { + console.log("Running on ARM architecture"); +} +``` + +### Python Platform Detection + +```python +# platform_utils.py +import platform +import sys + +class Platform: + @staticmethod + def is_windows(): + return sys.platform.startswith('win') + + @staticmethod + def is_macos(): + return sys.platform == 'darwin' + + @staticmethod + def is_linux(): + return sys.platform.startswith('linux') + + @staticmethod + def is_unix(): + return not Platform.is_windows() + + @staticmethod + def current(): + if Platform.is_windows(): + return 'windows' + elif Platform.is_macos(): + return 'macos' + elif Platform.is_linux(): + return 'linux' + return 'unknown' + + @staticmethod + def arch(): + return platform.machine() # 'x86_64', 'arm64', etc. + + @staticmethod + def version(): + return platform.version() + +# Usage +if Platform.is_windows(): + # Windows-specific code + print('Running on Windows') +elif Platform.is_macos(): + # macOS-specific code + print('Running on macOS') +elif Platform.is_linux(): + # Linux-specific code + print('Running on Linux') +``` diff --git a/.agents/skills/cross-platform-compatibility/references/platform-specific-dependencies.md b/.agents/skills/cross-platform-compatibility/references/platform-specific-dependencies.md new file mode 100644 index 00000000..f61a9ab4 --- /dev/null +++ b/.agents/skills/cross-platform-compatibility/references/platform-specific-dependencies.md @@ -0,0 +1,48 @@ +# Platform-Specific Dependencies + +## Platform-Specific Dependencies + +```json +// package.json +{ + "name": "my-app", + "dependencies": { + "common-dep": "^1.0.0" + }, + "optionalDependencies": { + "fsevents": "^2.3.2" + }, + "devDependencies": { + "@types/node": "^18.0.0" + } +} +``` + +```typescript +// platform-specific-module.ts +export async function loadPlatformModule() { + if (process.platform === "win32") { + return await import("./windows/module"); + } else if (process.platform === "darwin") { + return await import("./macos/module"); + } else { + return await import("./linux/module"); + } +} + +// Graceful fallback for optional dependencies +export function useFSEvents() { + try { + // fsevents is macOS only + if (process.platform === "darwin") { + const fsevents = require("fsevents"); + return fsevents; + } + } catch (error) { + console.warn("fsevents not available, using fallback"); + } + + // Fallback to chokidar or fs.watch + return require("chokidar"); +} +``` diff --git a/.agents/skills/cross-platform-compatibility/references/process-management.md b/.agents/skills/cross-platform-compatibility/references/process-management.md new file mode 100644 index 00000000..60a33e49 --- /dev/null +++ b/.agents/skills/cross-platform-compatibility/references/process-management.md @@ -0,0 +1,54 @@ +# Process Management + +## Process Management + +```typescript +// process-utils.ts +import { spawn, ChildProcess } from "child_process"; + +export class ProcessUtils { + // Kill process by PID with platform-specific signal + static kill(pid: number, signal?: string): void { + if (process.platform === "win32") { + // Windows doesn't support signals, use taskkill + spawn("taskkill", ["/pid", pid.toString(), "/f", "/t"]); + } else { + process.kill(pid, signal || "SIGTERM"); + } + } + + // Spawn process with platform-specific handling + static spawnCommand(command: string, args: string[] = []): ChildProcess { + if (process.platform === "win32") { + // Windows requires cmd.exe to run commands + return spawn("cmd", ["/c", command, ...args], { + stdio: "inherit", + shell: true, + }); + } + + return spawn(command, args, { + stdio: "inherit", + shell: true, + }); + } + + // Find process by name + static async findProcess(name: string): Promise { + if (process.platform === "win32") { + const { stdout } = await execAsync(`tasklist /FI "IMAGENAME eq ${name}"`); + // Parse Windows tasklist output + const pids: number[] = []; + const lines = stdout.split("\n"); + for (const line of lines) { + const match = line.match(/\s+(\d+)\s+/); + if (match) pids.push(parseInt(match[1])); + } + return pids; + } else { + const { stdout } = await execAsync(`pgrep ${name}`); + return stdout.split("\n").filter(Boolean).map(Number); + } + } +} +``` diff --git a/.agents/skills/cross-platform-compatibility/references/shell-commands.md b/.agents/skills/cross-platform-compatibility/references/shell-commands.md new file mode 100644 index 00000000..87014e8c --- /dev/null +++ b/.agents/skills/cross-platform-compatibility/references/shell-commands.md @@ -0,0 +1,60 @@ +# Shell Commands + +## Shell Commands + +```typescript +// shell-utils.ts +import { exec } from "child_process"; +import { promisify } from "util"; + +const execAsync = promisify(exec); + +export class ShellUtils { + // Execute command with platform-specific handling + static async execute(command: string): Promise { + try { + const { stdout, stderr } = await execAsync(command, { + shell: this.getShell(), + }); + if (stderr) console.error(stderr); + return stdout.trim(); + } catch (error) { + throw new Error(`Command failed: ${error.message}`); + } + } + + // Get platform-specific shell + static getShell(): string { + if (process.platform === "win32") { + return "cmd.exe"; + } + return process.env.SHELL || "/bin/sh"; + } + + // Platform-specific commands + static async listFiles(directory: string): Promise { + if (process.platform === "win32") { + return this.execute(`dir "${directory}"`); + } + return this.execute(`ls -la "${directory}"`); + } + + static async clearScreen(): Promise { + if (process.platform === "win32") { + await this.execute("cls"); + } else { + await this.execute("clear"); + } + } + + static async openFile(filepath: string): Promise { + if (process.platform === "win32") { + await this.execute(`start "" "${filepath}"`); + } else if (process.platform === "darwin") { + await this.execute(`open "${filepath}"`); + } else { + await this.execute(`xdg-open "${filepath}"`); + } + } +} +``` diff --git a/.agents/skills/cross-platform-compatibility/references/testing-across-platforms.md b/.agents/skills/cross-platform-compatibility/references/testing-across-platforms.md new file mode 100644 index 00000000..9f1ee27c --- /dev/null +++ b/.agents/skills/cross-platform-compatibility/references/testing-across-platforms.md @@ -0,0 +1,88 @@ +# Testing Across Platforms + +## Testing Across Platforms + +### GitHub Actions Matrix + +```yaml +# .github/workflows/test.yml +name: Cross-Platform Tests + +on: [push, pull_request] + +jobs: + test: + strategy: + matrix: + os: [ubuntu-latest, windows-latest, macos-latest] + node-version: [16, 18, 20] + + runs-on: ${{ matrix.os }} + + steps: + - uses: actions/checkout@v3 + + - name: Setup Node.js + uses: actions/setup-node@v3 + with: + node-version: ${{ matrix.node-version }} + + - name: Install dependencies + run: npm ci + + - name: Run tests + run: npm test + + - name: Platform-specific tests + if: runner.os == 'Windows' + run: npm run test:windows + + - name: Platform-specific tests + if: runner.os == 'macOS' + run: npm run test:macos + + - name: Platform-specific tests + if: runner.os == 'Linux' + run: npm run test:linux +``` + +### Platform-Specific Tests + +```typescript +// tests/platform.test.ts +import { Platform } from "../src/platform-utils"; + +describe("Platform-specific tests", () => { + describe("File paths", () => { + it("should handle paths correctly", () => { + const configPath = path.join(os.homedir(), "config.json"); + + if (Platform.isWindows) { + expect(configPath).toMatch(/^[A-Z]:\\/); + } else { + expect(configPath).toMatch(/^\//); + } + }); + }); + + describe.skipIf(Platform.isWindows)("Unix-only tests", () => { + it("should work with symlinks", () => { + // Symlink tests + }); + + it("should handle file permissions", () => { + // Permission tests + }); + }); + + describe.skipIf(!Platform.isWindows)("Windows-only tests", () => { + it("should work with UNC paths", () => { + // UNC path tests + }); + + it("should handle drive letters", () => { + // Drive letter tests + }); + }); +}); +``` diff --git a/.agents/skills/cross-platform-compatibility/scripts/scaffold-tests.sh b/.agents/skills/cross-platform-compatibility/scripts/scaffold-tests.sh new file mode 100755 index 00000000..0aa2fa78 --- /dev/null +++ b/.agents/skills/cross-platform-compatibility/scripts/scaffold-tests.sh @@ -0,0 +1,18 @@ +#!/bin/bash +# scaffold-tests.sh - Generate test file scaffolding +# Usage: ./scaffold-tests.sh [--framework jest|pytest|mocha] + +set -euo pipefail + +SOURCE_FILE="${{1:?Usage: $0 [--framework jest|pytest|mocha]}}" +FRAMEWORK="${{2:-jest}}" + +echo "Scaffolding tests for: $SOURCE_FILE (framework: $FRAMEWORK)" + +# TODO: Implement test scaffolding logic +# - Parse source file for exported functions/classes +# - Generate test stubs for each export +# - Include setup/teardown boilerplate +# - Add common assertion patterns + +echo "Test scaffolding complete." diff --git a/.agents/skills/cross-platform-compatibility/templates/test-template.js b/.agents/skills/cross-platform-compatibility/templates/test-template.js new file mode 100644 index 00000000..1dd9de31 --- /dev/null +++ b/.agents/skills/cross-platform-compatibility/templates/test-template.js @@ -0,0 +1,27 @@ +// Test Template +// TODO: Customize for your testing framework and project + +describe('ModuleName', () => { + // Setup + beforeEach(() => { + // TODO: Add test setup + }); + + afterEach(() => { + // TODO: Add cleanup + }); + + describe('functionName', () => { + it('should handle the happy path', () => { + // TODO: Add assertion + }); + + it('should handle edge cases', () => { + // TODO: Add edge case tests + }); + + it('should handle errors gracefully', () => { + // TODO: Add error handling tests + }); + }); +}); diff --git a/.agents/skills/impeccable/SKILL.md b/.agents/skills/impeccable/SKILL.md new file mode 100644 index 00000000..8af38df3 --- /dev/null +++ b/.agents/skills/impeccable/SKILL.md @@ -0,0 +1,163 @@ +--- +name: impeccable +description: Use when the user wants to design, redesign, shape, critique, audit, polish, clarify, distill, harden, optimize, adapt, animate, colorize, extract, or otherwise improve a frontend interface. Covers websites, landing pages, dashboards, product UI, app shells, components, forms, settings, onboarding, and empty states. Handles UX review, visual hierarchy, information architecture, cognitive load, accessibility, performance, responsive behavior, theming, anti-patterns, typography, fonts, spacing, layout, alignment, color, motion, micro-interactions, UX copy, error states, edge cases, i18n, and reusable design systems or tokens. Also use for bland designs that need to become bolder or more delightful, loud designs that should become quieter, live browser iteration on UI elements, or ambitious visual effects that should feel technically extraordinary. Not for backend-only or non-UI tasks. +--- + +Designs and iterates production-grade frontend interfaces. Real working code, committed design choices, exceptional craft. + +## Setup + +Before any design work or file edits: + +1. Load context (PRODUCT.md / DESIGN.md) via the loader script. +2. Identify the register and load the matching register reference (brand.md or product.md). +3. **If the user invoked a sub-command (e.g. `craft`, `shape`, `audit`), load its reference file too.** This is non-negotiable: `craft` without `craft.md` loaded means you'll skip the shape-and-confirm step the user expects. + +Skipping these produces generic output that ignores the project. + +### 1. Context gathering + +Two files, case-insensitive. The loader looks at the project root by default and falls back to `.agents/context/` and `docs/` if the root is clean. Override with `IMPECCABLE_CONTEXT_DIR=path/to/dir` (absolute or relative to cwd). + +- **PRODUCT.md**: required. Users, brand, tone, anti-references, strategic principles. +- **DESIGN.md**: optional, strongly recommended. Colors, typography, elevation, components. + +Load both in one call: + +```bash +node .agents/skills/impeccable/scripts/load-context.mjs +``` + +Consume the full JSON output. Never pipe through `head`, `tail`, `grep`, or `jq`. The output's `contextDir` field tells you where the files were resolved from. + +If the output is already in this session's conversation history, don't re-run. Exceptions requiring a fresh load: you just ran `$impeccable teach` or `$impeccable document` (they rewrite the files), or the user manually edited one. + +`$impeccable live` already warms context via `live.mjs`. If you've run `live.mjs`, don't also run `load-context.mjs` this session. + +If PRODUCT.md is missing, empty, or placeholder (`[TODO]` markers, <200 chars): run `$impeccable teach`, then resume the user's original task with the fresh context. If the original task was `$impeccable craft`, resume into `$impeccable shape` before any implementation work. + +If DESIGN.md is missing: nudge once per session (*"Run `$impeccable document` for more on-brand output"*), then proceed. + +### 2. Register + +Every design task is **brand** (marketing, landing, campaign, long-form content, portfolio: design IS the product) or **product** (app UI, admin, dashboard, tool: design SERVES the product). + +Identify before designing. Priority: (1) cue in the task itself ("landing page" vs "dashboard"); (2) the surface in focus (the page, file, or route being worked on); (3) `register` field in PRODUCT.md. First match wins. + +If PRODUCT.md lacks the `register` field (legacy), infer it once from its "Users" and "Product Purpose" sections, then cache the inferred value for the session. Suggest the user run `$impeccable teach` to add the field explicitly. + +Load the matching reference: [reference/brand.md](reference/brand.md) or [reference/product.md](reference/product.md). The shared design laws below apply to both. + +## Shared design laws + +Apply to every design, both registers. Match implementation complexity to the aesthetic vision: maximalism needs elaborate code, minimalism needs precision. Interpret creatively. Vary across projects; never converge on the same choices. GPT is capable of extraordinary work. Don't hold back. + +### Color + +- Use OKLCH. Reduce chroma as lightness approaches 0 or 100; high chroma at extremes looks garish. +- Never use `#000` or `#fff`. Tint every neutral toward the brand hue (chroma 0.005–0.01 is enough). +- Pick a **color strategy** before picking colors. Four steps on the commitment axis: + - **Restrained**: tinted neutrals + one accent ≤10%. Product default; brand minimalism. + - **Committed**: one saturated color carries 30–60% of the surface. Brand default for identity-driven pages. + - **Full palette**: 3–4 named roles, each used deliberately. Brand campaigns; product data viz. + - **Drenched**: the surface IS the color. Brand heroes, campaign pages. +- The "one accent ≤10%" rule is Restrained only. Committed / Full palette / Drenched exceed it on purpose. Don't collapse every design to Restrained by reflex. + +### Theme + +Dark vs. light is never a default. Not dark "because tools look cool dark." Not light "to be safe." + +Before choosing, write one sentence of physical scene: who uses this, where, under what ambient light, in what mood. If the sentence doesn't force the answer, it's not concrete enough. Add detail until it does. + +"Observability dashboard" does not force an answer. "SRE glancing at incident severity on a 27-inch monitor at 2am in a dim room" does. Run the sentence, not the category. + +### Typography + +- Cap body line length at 65–75ch. +- Hierarchy through scale + weight contrast (≥1.25 ratio between steps). Avoid flat scales. + +### Layout + +- Vary spacing for rhythm. Same padding everywhere is monotony. +- Cards are the lazy answer. Use them only when they're truly the best affordance. Nested cards are always wrong. +- Don't wrap everything in a container. Most things don't need one. + +### Motion + +- Don't animate CSS layout properties. +- Ease out with exponential curves (ease-out-quart / quint / expo). No bounce, no elastic. + +### Absolute bans + +Match-and-refuse. If you're about to write any of these, rewrite the element with different structure. + +- **Side-stripe borders.** `border-left` or `border-right` greater than 1px as a colored accent on cards, list items, callouts, or alerts. Never intentional. Rewrite with full borders, background tints, leading numbers/icons, or nothing. +- **Gradient text.** `background-clip: text` combined with a gradient background. Decorative, never meaningful. Use a single solid color. Emphasis via weight or size. +- **Glassmorphism as default.** Blurs and glass cards used decoratively. Rare and purposeful, or nothing. +- **The hero-metric template.** Big number, small label, supporting stats, gradient accent. SaaS cliché. +- **Identical card grids.** Same-sized cards with icon + heading + text, repeated endlessly. +- **Modal as first thought.** Modals are usually laziness. Exhaust inline / progressive alternatives first. + +### Copy + +- Every word earns its place. No restated headings, no intros that repeat the title. +- **No em dashes.** Use commas, colons, semicolons, periods, or parentheses. Also not `--`. + +### The AI slop test + +If someone could look at this interface and say "AI made that" without doubt, it's failed. Cross-register failures are the absolute bans above. Register-specific failures live in each reference. + +**Category-reflex check.** Run at two altitudes; the second one catches what the first one misses. + +- **First-order:** if someone could guess the theme + palette from the category alone ("observability → dark blue", "healthcare → white + teal", "finance → navy + gold", "crypto → neon on black"), it's the first training-data reflex. Rework the scene sentence and color strategy until the answer isn't obvious from the domain. +- **Second-order:** if someone could guess the aesthetic family from category-plus-anti-references ("AI workflow tool that's not SaaS-cream → editorial-typographic", "fintech that's not navy-and-gold → terminal-native dark mode"), it's the trap one tier deeper. The first reflex was avoided; the second wasn't. Rework until both answers are not obvious. The brand register's [reflex-reject aesthetic lanes](reference/brand.md) list catches the currently-saturated families. + +## Commands + +| Command | Category | Description | Reference | +|---|---|---|---| +| `craft [feature]` | Build | Shape, then build a feature end-to-end | [reference/craft.md](reference/craft.md) | +| `shape [feature]` | Build | Plan UX/UI before writing code | [reference/shape.md](reference/shape.md) | +| `teach` | Build | Set up PRODUCT.md and DESIGN.md context | [reference/teach.md](reference/teach.md) | +| `document` | Build | Generate DESIGN.md from existing project code | [reference/document.md](reference/document.md) | +| `extract [target]` | Build | Pull reusable tokens and components into design system | [reference/extract.md](reference/extract.md) | +| `critique [target]` | Evaluate | UX design review with heuristic scoring | [reference/critique.md](reference/critique.md) | +| `audit [target]` | Evaluate | Technical quality checks (a11y, perf, responsive) | [reference/audit.md](reference/audit.md) | +| `polish [target]` | Refine | Final quality pass before shipping | [reference/polish.md](reference/polish.md) | +| `bolder [target]` | Refine | Amplify safe or bland designs | [reference/bolder.md](reference/bolder.md) | +| `quieter [target]` | Refine | Tone down aggressive or overstimulating designs | [reference/quieter.md](reference/quieter.md) | +| `distill [target]` | Refine | Strip to essence, remove complexity | [reference/distill.md](reference/distill.md) | +| `harden [target]` | Refine | Production-ready: errors, i18n, edge cases | [reference/harden.md](reference/harden.md) | +| `onboard [target]` | Refine | Design first-run flows, empty states, activation | [reference/onboard.md](reference/onboard.md) | +| `animate [target]` | Enhance | Add purposeful animations and motion | [reference/animate.md](reference/animate.md) | +| `colorize [target]` | Enhance | Add strategic color to monochromatic UIs | [reference/colorize.md](reference/colorize.md) | +| `typeset [target]` | Enhance | Improve typography hierarchy and fonts | [reference/typeset.md](reference/typeset.md) | +| `layout [target]` | Enhance | Fix spacing, rhythm, and visual hierarchy | [reference/layout.md](reference/layout.md) | +| `delight [target]` | Enhance | Add personality and memorable touches | [reference/delight.md](reference/delight.md) | +| `overdrive [target]` | Enhance | Push past conventional limits | [reference/overdrive.md](reference/overdrive.md) | +| `clarify [target]` | Fix | Improve UX copy, labels, and error messages | [reference/clarify.md](reference/clarify.md) | +| `adapt [target]` | Fix | Adapt for different devices and screen sizes | [reference/adapt.md](reference/adapt.md) | +| `optimize [target]` | Fix | Diagnose and fix UI performance | [reference/optimize.md](reference/optimize.md) | +| `live` | Iterate | Visual variant mode: pick elements in the browser, generate alternatives | [reference/live.md](reference/live.md) | + +Plus two management commands: `pin ` and `unpin `, detailed below. + +### Routing rules + +1. **No argument**: render the table above as the user-facing command menu, grouped by category. Ask what they'd like to do. +2. **First word matches a command**: load its reference file and follow its instructions. Everything after the command name is the target. +3. **First word doesn't match**: general design invocation. Apply the setup steps, shared design laws, and the loaded register reference, using the full argument as context. + +Setup (context gathering, register) is already loaded by then; sub-commands don't re-invoke `$impeccable`. + +If the first word is `craft`, setup still runs first, but [reference/craft.md](reference/craft.md) owns the rest of the flow. If setup invokes `teach` as a blocker, finish teach, refresh context, then resume the original command and target. + +## Pin / Unpin + +**Pin** creates a standalone shortcut so `$` invokes `$impeccable ` directly. **Unpin** removes it. The script writes to every harness directory present in the project. + +```bash +node .agents/skills/impeccable/scripts/pin.mjs +``` + +Valid `` is any command from the table above. Report the script's result concisely. Confirm the new shortcut on success, relay stderr verbatim on error. \ No newline at end of file diff --git a/.agents/skills/impeccable/agents/openai.yaml b/.agents/skills/impeccable/agents/openai.yaml new file mode 100644 index 00000000..ee6cae77 --- /dev/null +++ b/.agents/skills/impeccable/agents/openai.yaml @@ -0,0 +1,4 @@ +interface: + display_name: Impeccable + short_description: Use when the user wants to design, redesign, shape, critique, audit, polish, clarify,... + default_prompt: Use Impeccable to redesign, critique, audit, or polish this frontend. \ No newline at end of file diff --git a/.agents/skills/impeccable/reference/adapt.md b/.agents/skills/impeccable/reference/adapt.md new file mode 100644 index 00000000..21bb0255 --- /dev/null +++ b/.agents/skills/impeccable/reference/adapt.md @@ -0,0 +1,190 @@ +> **Additional context needed**: target platforms/devices and usage contexts. + +Adapt an existing design to a different context: another screen size, device, platform, or use case. The trap is treating adaptation as scaling. The job is rethinking the experience for the new context. + + +--- + +## Assess Adaptation Challenge + +Understand what needs adaptation and why: + +1. **Identify the source context**: + - What was it designed for originally? (Desktop web? Mobile app?) + - What assumptions were made? (Large screen? Mouse input? Fast connection?) + - What works well in current context? + +2. **Understand target context**: + - **Device**: Mobile, tablet, desktop, TV, watch, print? + - **Input method**: Touch, mouse, keyboard, voice, gamepad? + - **Screen constraints**: Size, resolution, orientation? + - **Connection**: Fast wifi, slow 3G, offline? + - **Usage context**: On-the-go vs desk, quick glance vs focused reading? + - **User expectations**: What do users expect on this platform? + +3. **Identify adaptation challenges**: + - What won't fit? (Content, navigation, features) + - What won't work? (Hover states on touch, tiny touch targets) + - What's inappropriate? (Desktop patterns on mobile, mobile patterns on desktop) + +**CRITICAL**: Adaptation is rethinking the experience for the new context, not scaling pixels. + +## Plan Adaptation Strategy + +Create context-appropriate strategy: + +### Mobile Adaptation (Desktop → Mobile) + +**Layout Strategy**: +- Single column instead of multi-column +- Vertical stacking instead of side-by-side +- Full-width components instead of fixed widths +- Bottom navigation instead of top/side navigation + +**Interaction Strategy**: +- Touch targets 44x44px minimum (not hover-dependent) +- Swipe gestures where appropriate (lists, carousels) +- Bottom sheets instead of dropdowns +- Thumbs-first design (controls within thumb reach) +- Larger tap areas with more spacing + +**Content Strategy**: +- Progressive disclosure (don't show everything at once) +- Prioritize primary content (secondary content in tabs/accordions) +- Shorter text (more concise) +- Larger text (16px minimum) + +**Navigation Strategy**: +- Hamburger menu or bottom navigation +- Reduce navigation complexity +- Sticky headers for context +- Back button in navigation flow + +### Tablet Adaptation (Hybrid Approach) + +**Layout Strategy**: +- Two-column layouts (not single or three-column) +- Side panels for secondary content +- Master-detail views (list + detail) +- Adaptive based on orientation (portrait vs landscape) + +**Interaction Strategy**: +- Support both touch and pointer +- Touch targets 44x44px but allow denser layouts than phone +- Side navigation drawers +- Multi-column forms where appropriate + +### Desktop Adaptation (Mobile → Desktop) + +**Layout Strategy**: +- Multi-column layouts (use horizontal space) +- Side navigation always visible +- Multiple information panels simultaneously +- Fixed widths with max-width constraints (don't stretch to 4K) + +**Interaction Strategy**: +- Hover states for additional information +- Keyboard shortcuts +- Right-click context menus +- Drag and drop where helpful +- Multi-select with Shift/Cmd + +**Content Strategy**: +- Show more information upfront (less progressive disclosure) +- Data tables with many columns +- Richer visualizations +- More detailed descriptions + +### Print Adaptation (Screen → Print) + +**Layout Strategy**: +- Page breaks at logical points +- Remove navigation, footer, interactive elements +- Black and white (or limited color) +- Proper margins for binding + +**Content Strategy**: +- Expand shortened content (show full URLs, hidden sections) +- Add page numbers, headers, footers +- Include metadata (print date, page title) +- Convert charts to print-friendly versions + +### Email Adaptation (Web → Email) + +**Layout Strategy**: +- Narrow width (600px max) +- Single column only +- Inline CSS (no external stylesheets) +- Table-based layouts (for email client compatibility) + +**Interaction Strategy**: +- Large, obvious CTAs (buttons not text links) +- No hover states (not reliable) +- Deep links to web app for complex interactions + +## Implement Adaptations + +Apply changes systematically: + +### Responsive Breakpoints + +Choose appropriate breakpoints: +- Mobile: 320px-767px +- Tablet: 768px-1023px +- Desktop: 1024px+ +- Or content-driven breakpoints (where design breaks) + +### Layout Adaptation Techniques + +- **CSS Grid/Flexbox**: Reflow layouts automatically +- **Container Queries**: Adapt based on container, not viewport +- **`clamp()`**: Fluid sizing between min and max +- **Media queries**: Different styles for different contexts +- **Display properties**: Show/hide elements per context + +### Touch Adaptation + +- Increase touch target sizes (44x44px minimum) +- Add more spacing between interactive elements +- Remove hover-dependent interactions +- Add touch feedback (ripples, highlights) +- Consider thumb zones (easier to reach bottom than top) + +### Content Adaptation + +- Use `display: none` sparingly (still downloads) +- Progressive enhancement (core content first, enhancements on larger screens) +- Lazy loading for off-screen content +- Responsive images (`srcset`, `picture` element) + +### Navigation Adaptation + +- Transform complex nav to hamburger/drawer on mobile +- Bottom nav bar for mobile apps +- Persistent side navigation on desktop +- Breadcrumbs on smaller screens for context + +**IMPORTANT**: Test on real devices. Device emulation in DevTools is helpful but not perfect. + +**NEVER**: +- Hide core functionality on mobile (if it matters, make it work) +- Assume desktop = powerful device (consider accessibility, older machines) +- Use different information architecture across contexts (confusing) +- Break user expectations for platform (mobile users expect mobile patterns) +- Forget landscape orientation on mobile/tablet +- Use generic breakpoints blindly (use content-driven breakpoints) +- Ignore touch on desktop (many desktop devices have touch) + +## Verify Adaptations + +Test thoroughly across contexts: + +- **Real devices**: Test on actual phones, tablets, desktops +- **Different orientations**: Portrait and landscape +- **Different browsers**: Safari, Chrome, Firefox, Edge +- **Different OS**: iOS, Android, Windows, macOS +- **Different input methods**: Touch, mouse, keyboard +- **Edge cases**: Very small screens (320px), very large screens (4K) +- **Slow connections**: Test on throttled network + +When the adaptation feels native to each context, hand off to `$impeccable polish` for the final pass. diff --git a/.agents/skills/impeccable/reference/animate.md b/.agents/skills/impeccable/reference/animate.md new file mode 100644 index 00000000..48b5e268 --- /dev/null +++ b/.agents/skills/impeccable/reference/animate.md @@ -0,0 +1,175 @@ +> **Additional context needed**: performance constraints. + +Add motion that conveys state, gives feedback, and clarifies hierarchy. Cut motion that exists only for decoration. Animation fatigue is a real cost; spend the budget on the moments that need it. + +--- + +## Register + +Brand: orchestrated page-load sequences, staggered reveals, scroll-driven animation. Motion is part of the voice; one well-rehearsed entrance beats scattered micro-interactions. + +Product: 150–250 ms on most transitions. Motion conveys state: feedback, reveal, loading, transitions between views. No page-load choreography; users are in a task and won't wait for it. + +--- + +## Assess Animation Opportunities + +Analyze where motion would improve the experience: + +1. **Identify static areas**: + - **Missing feedback**: Actions without visual acknowledgment (button clicks, form submission, etc.) + - **Jarring transitions**: Instant state changes that feel abrupt (show/hide, page loads, route changes) + - **Unclear relationships**: Spatial or hierarchical relationships that aren't obvious + - **Lack of delight**: Functional but joyless interactions + - **Missed guidance**: Opportunities to direct attention or explain behavior + +2. **Understand the context**: + - What's the personality? (Playful vs serious, energetic vs calm) + - What's the performance budget? (Mobile-first? Complex page?) + - Who's the audience? (Motion-sensitive users? Power users who want speed?) + - What matters most? (One hero animation vs many micro-interactions?) + +If any of these are unclear from the codebase, STOP and use Codex's structured user-input/question tool when available; if unavailable, ask directly in chat to clarify what you cannot infer. + +**CRITICAL**: Respect `prefers-reduced-motion`. Always provide non-animated alternatives for users who need them. + +## Plan Animation Strategy + +Create a purposeful animation plan: + +- **Hero moment**: What's the ONE signature animation? (Page load? Hero section? Key interaction?) +- **Feedback layer**: Which interactions need acknowledgment? +- **Transition layer**: Which state changes need smoothing? +- **Delight layer**: Where can we surprise and delight? + +**IMPORTANT**: One well-orchestrated experience beats scattered animations everywhere. Focus on high-impact moments. + +## Implement Animations + +Add motion systematically across these categories: + +### Entrance Animations +- **Page load choreography**: Stagger element reveals (100-150ms delays), fade + slide combinations +- **Hero section**: Dramatic entrance for primary content (scale, parallax, or creative effects) +- **Content reveals**: Scroll-triggered animations using intersection observer +- **Modal/drawer entry**: Smooth slide + fade, backdrop fade, focus management + +### Micro-interactions +- **Button feedback**: + - Hover: Subtle scale (1.02-1.05), color shift, shadow increase + - Click: Quick scale down then up (0.95 → 1), ripple effect + - Loading: Spinner or pulse state +- **Form interactions**: + - Input focus: Border color transition, slight scale or glow + - Validation: Shake on error, check mark on success, smooth color transitions +- **Toggle switches**: Smooth slide + color transition (200-300ms) +- **Checkboxes/radio**: Check mark animation, ripple effect +- **Like/favorite**: Scale + rotation, particle effects, color transition + +### State Transitions +- **Show/hide**: Fade + slide (not instant), appropriate timing (200-300ms) +- **Expand/collapse**: Height transition with overflow handling, icon rotation +- **Loading states**: Skeleton screen fades, spinner animations, progress bars +- **Success/error**: Color transitions, icon animations, gentle scale pulse +- **Enable/disable**: Opacity transitions, cursor changes + +### Navigation & Flow +- **Page transitions**: Crossfade between routes, shared element transitions +- **Tab switching**: Slide indicator, content fade/slide +- **Carousel/slider**: Smooth transforms, snap points, momentum +- **Scroll effects**: Parallax layers, sticky headers with state changes, scroll progress indicators + +### Feedback & Guidance +- **Hover hints**: Tooltip fade-ins, cursor changes, element highlights +- **Drag & drop**: Lift effect (shadow + scale), drop zone highlights, smooth repositioning +- **Copy/paste**: Brief highlight flash on paste, "copied" confirmation +- **Focus flow**: Highlight path through form or workflow + +### Delight Moments +- **Empty states**: Subtle floating animations on illustrations +- **Completed actions**: Confetti, check mark flourish, success celebrations +- **Easter eggs**: Hidden interactions for discovery +- **Contextual animation**: Weather effects, time-of-day themes, seasonal touches + +## Technical Implementation + +Use appropriate techniques for each animation: + +### Timing & Easing + +**Durations by purpose:** +- **100-150ms**: Instant feedback (button press, toggle) +- **200-300ms**: State changes (hover, menu open) +- **300-500ms**: Layout changes (accordion, modal) +- **500-800ms**: Entrance animations (page load) + +**Easing curves (use these, not CSS defaults):** +```css +/* Recommended: natural deceleration */ +--ease-out-quart: cubic-bezier(0.25, 1, 0.5, 1); /* Smooth */ +--ease-out-quint: cubic-bezier(0.22, 1, 0.36, 1); /* Slightly snappier */ +--ease-out-expo: cubic-bezier(0.16, 1, 0.3, 1); /* Confident, decisive */ + +/* AVOID: feel dated and tacky */ +/* bounce: cubic-bezier(0.34, 1.56, 0.64, 1); */ +/* elastic: cubic-bezier(0.68, -0.6, 0.32, 1.6); */ +``` + +**Exit animations are faster than entrances.** Use ~75% of enter duration. + +### CSS Animations +```css +/* Prefer for simple, declarative animations */ +- transitions for state changes +- @keyframes for complex sequences +- transform and opacity for reliable movement +- blur, filters, masks, clip paths, shadows, and color shifts for premium atmospheric effects when verified smooth +``` + +### JavaScript Animation +```javascript +/* Use for complex, interactive animations */ +- Web Animations API for programmatic control +- Framer Motion for React +- GSAP for complex sequences +``` + +### Performance +- **Motion materials**: Use transform/opacity for reliable movement, but use blur, filters, masks, shadows, and color shifts when they materially improve the effect +- **Layout safety**: Avoid casual animation of layout-driving properties (`width`, `height`, `top`, `left`, margins) +- **will-change**: Add sparingly for known expensive animations +- **Bound expensive effects**: Keep blur/filter/shadow areas small or isolated, use `contain` where appropriate +- **Monitor FPS**: Ensure 60fps on target devices + +### Accessibility +```css +@media (prefers-reduced-motion: reduce) { + * { + animation-duration: 0.01ms !important; + animation-iteration-count: 1 !important; + transition-duration: 0.01ms !important; + } +} +``` + +**NEVER**: +- Use bounce or elastic easing curves; they feel dated and draw attention to the animation itself +- Animate layout properties casually (`width`, `height`, `top`, `left`, margins) when transform, FLIP, or grid-based techniques would work +- Use durations over 500ms for feedback (it feels laggy) +- Animate without purpose (every animation needs a reason) +- Ignore `prefers-reduced-motion` (this is an accessibility violation) +- Animate everything (animation fatigue makes interfaces feel exhausting) +- Block interaction during animations unless intentional + +## Verify Quality + +Test animations thoroughly: + +- **Smooth at 60fps**: No jank on target devices +- **Feels natural**: Easing curves feel organic, not robotic +- **Appropriate timing**: Not too fast (jarring) or too slow (laggy) +- **Reduced motion works**: Animations disabled or simplified appropriately +- **Doesn't block**: Users can interact during/after animations +- **Adds value**: Makes interface clearer or more delightful + +When the motion clarifies state instead of decorating it, hand off to `$impeccable polish` for the final pass. diff --git a/.agents/skills/impeccable/reference/audit.md b/.agents/skills/impeccable/reference/audit.md new file mode 100644 index 00000000..10f5572f --- /dev/null +++ b/.agents/skills/impeccable/reference/audit.md @@ -0,0 +1,133 @@ +Run systematic **technical** quality checks and generate a comprehensive report. Don't fix issues; document them for other commands to address. + +This is a code-level audit, not a design critique. Check what's measurable and verifiable in the implementation. + +## Diagnostic Scan + +Run comprehensive checks across 5 dimensions. Score each dimension 0-4 using the criteria below. + +### 1. Accessibility (A11y) + +**Check for**: +- **Contrast issues**: Text contrast ratios < 4.5:1 (or 7:1 for AAA) +- **Missing ARIA**: Interactive elements without proper roles, labels, or states +- **Keyboard navigation**: Missing focus indicators, illogical tab order, keyboard traps +- **Semantic HTML**: Improper heading hierarchy, missing landmarks, divs instead of buttons +- **Alt text**: Missing or poor image descriptions +- **Form issues**: Inputs without labels, poor error messaging, missing required indicators + +**Score 0-4**: 0=Inaccessible (fails WCAG A), 1=Major gaps (few ARIA labels, no keyboard nav), 2=Partial (some a11y effort, significant gaps), 3=Good (WCAG AA mostly met, minor gaps), 4=Excellent (WCAG AA fully met, approaches AAA) + +### 2. Performance + +**Check for**: +- **Layout thrashing**: Reading/writing layout properties in loops +- **Expensive animations**: Casual layout-property animation, unbounded blur/filter/shadow effects, or effects that visibly drop frames +- **Missing optimization**: Images without lazy loading, unoptimized assets, missing will-change +- **Bundle size**: Unnecessary imports, unused dependencies +- **Render performance**: Unnecessary re-renders, missing memoization + +**Score 0-4**: 0=Severe issues (layout thrash, unoptimized everything), 1=Major problems (no lazy loading, expensive animations), 2=Partial (some optimization, gaps remain), 3=Good (mostly optimized, minor improvements possible), 4=Excellent (fast, lean, well-optimized) + +### 3. Theming + +**Check for**: +- **Hard-coded colors**: Colors not using design tokens +- **Broken dark mode**: Missing dark mode variants, poor contrast in dark theme +- **Inconsistent tokens**: Using wrong tokens, mixing token types +- **Theme switching issues**: Values that don't update on theme change + +**Score 0-4**: 0=No theming (hard-coded everything), 1=Minimal tokens (mostly hard-coded), 2=Partial (tokens exist but inconsistently used), 3=Good (tokens used, minor hard-coded values), 4=Excellent (full token system, dark mode works perfectly) + +### 4. Responsive Design + +**Check for**: +- **Fixed widths**: Hard-coded widths that break on mobile +- **Touch targets**: Interactive elements < 44x44px +- **Horizontal scroll**: Content overflow on narrow viewports +- **Text scaling**: Layouts that break when text size increases +- **Missing breakpoints**: No mobile/tablet variants + +**Score 0-4**: 0=Desktop-only (breaks on mobile), 1=Major issues (some breakpoints, many failures), 2=Partial (works on mobile, rough edges), 3=Good (responsive, minor touch target or overflow issues), 4=Excellent (fluid, all viewports, proper touch targets) + +### 5. Anti-Patterns (CRITICAL) + +Check against ALL the **DON'T** guidelines from the parent impeccable skill (already loaded in this context). Look for AI slop tells (AI color palette, gradient text, glassmorphism, hero metrics, card grids, generic fonts) and general design anti-patterns (gray on color, nested cards, bounce easing, redundant copy). + +**Score 0-4**: 0=AI slop gallery (5+ tells), 1=Heavy AI aesthetic (3-4 tells), 2=Some tells (1-2 noticeable), 3=Mostly clean (subtle issues only), 4=No AI tells (distinctive, intentional design) + +## Generate Report + +### Audit Health Score + +| # | Dimension | Score | Key Finding | +|---|-----------|-------|-------------| +| 1 | Accessibility | ? | [most critical a11y issue or "--"] | +| 2 | Performance | ? | | +| 3 | Responsive Design | ? | | +| 4 | Theming | ? | | +| 5 | Anti-Patterns | ? | | +| **Total** | | **??/20** | **[Rating band]** | + +**Rating bands**: 18-20 Excellent (minor polish), 14-17 Good (address weak dimensions), 10-13 Acceptable (significant work needed), 6-9 Poor (major overhaul), 0-5 Critical (fundamental issues) + +### Anti-Patterns Verdict +**Start here.** Pass/fail: Does this look AI-generated? List specific tells. Be brutally honest. + +### Executive Summary +- Audit Health Score: **??/20** ([rating band]) +- Total issues found (count by severity: P0/P1/P2/P3) +- Top 3-5 critical issues +- Recommended next steps + +### Detailed Findings by Severity + +Tag every issue with **P0-P3 severity**: +- **P0 Blocking**: Prevents task completion. Fix immediately +- **P1 Major**: Significant difficulty or WCAG AA violation. Fix before release +- **P2 Minor**: Annoyance, workaround exists. Fix in next pass +- **P3 Polish**: Nice-to-fix, no real user impact. Fix if time permits + +For each issue, document: +- **[P?] Issue name** +- **Location**: Component, file, line +- **Category**: Accessibility / Performance / Theming / Responsive / Anti-Pattern +- **Impact**: How it affects users +- **WCAG/Standard**: Which standard it violates (if applicable) +- **Recommendation**: How to fix it +- **Suggested command**: Which command to use (prefer: $impeccable adapt, $impeccable animate, $impeccable audit, $impeccable bolder, $impeccable clarify, $impeccable colorize, $impeccable critique, $impeccable delight, $impeccable distill, $impeccable document, $impeccable harden, $impeccable layout, $impeccable onboard, $impeccable optimize, $impeccable overdrive, $impeccable polish, $impeccable quieter, $impeccable shape, $impeccable typeset) + +### Patterns & Systemic Issues + +Identify recurring problems that indicate systemic gaps rather than one-off mistakes: +- "Hard-coded colors appear in 15+ components, should use design tokens" +- "Touch targets consistently too small (<44px) throughout mobile experience" + +### Positive Findings + +Note what's working well: good practices to maintain and replicate. + +## Recommended Actions + +List recommended commands in priority order (P0 first, then P1, then P2): + +1. **[P?] `$command-name`**: Brief description (specific context from audit findings) +2. **[P?] `$command-name`**: Brief description (specific context) + +**Rules**: Only recommend commands from: $impeccable adapt, $impeccable animate, $impeccable audit, $impeccable bolder, $impeccable clarify, $impeccable colorize, $impeccable critique, $impeccable delight, $impeccable distill, $impeccable document, $impeccable harden, $impeccable layout, $impeccable onboard, $impeccable optimize, $impeccable overdrive, $impeccable polish, $impeccable quieter, $impeccable shape, $impeccable typeset. Map findings to the most appropriate command. End with `$impeccable polish` as the final step if any fixes were recommended. + +After presenting the summary, tell the user: + +> You can ask me to run these one at a time, all at once, or in any order you prefer. +> +> Re-run `$impeccable audit` after fixes to see your score improve. + +**IMPORTANT**: Be thorough but actionable. Too many P3 issues creates noise. Focus on what actually matters. + +**NEVER**: +- Report issues without explaining impact (why does this matter?) +- Provide generic recommendations (be specific and actionable) +- Skip positive findings (celebrate what works) +- Forget to prioritize (everything can't be P0) +- Report false positives without verification + diff --git a/.agents/skills/impeccable/reference/bolder.md b/.agents/skills/impeccable/reference/bolder.md new file mode 100644 index 00000000..25e94d59 --- /dev/null +++ b/.agents/skills/impeccable/reference/bolder.md @@ -0,0 +1,113 @@ +When asked for "bolder," AI defaults to the same tired tricks: cyan/purple gradients, glassmorphism, neon accents on dark backgrounds, gradient text on metrics. These are the opposite of bold. Reject them first, then increase visual impact and personality through stronger hierarchy, committed scale, and decisive type. + +--- + +## Register + +Brand: "bolder" means distinctive. Extreme scale, unexpected color, typographic risk, committed POV. + +Product: "bolder" rarely means theatrics; those undermine trust. It means stronger hierarchy, clearer weight contrast, one sharper accent, more committed density. The amplification is in clarity, not drama. + +--- + +## Assess Current State + +Analyze what makes the design feel too safe or boring: + +1. **Identify weakness sources**: + - **Generic choices**: System fonts, basic colors, standard layouts + - **Timid scale**: Everything is medium-sized with no drama + - **Low contrast**: Everything has similar visual weight + - **Static**: No motion, no energy, no life + - **Predictable**: Standard patterns with no surprises + - **Flat hierarchy**: Nothing stands out or commands attention + +2. **Understand the context**: + - What's the brand personality? (How far can we push?) + - What's the purpose? (Marketing can be bolder than financial dashboards) + - Who's the audience? (What will resonate?) + - What are the constraints? (Brand guidelines, accessibility, performance) + +If any of these are unclear from the codebase, STOP and use Codex's structured user-input/question tool when available; if unavailable, ask directly in chat to clarify what you cannot infer. + +**CRITICAL**: "Bolder" doesn't mean chaotic or garish. It means distinctive, memorable, and confident. Think intentional drama, not random chaos. + +**WARNING - AI SLOP TRAP**: Review ALL the DON'T guidelines from the parent impeccable skill (already loaded in this context) before proceeding. Bold means distinctive, not "more effects." + +## Plan Amplification + +Create a strategy to increase impact while maintaining coherence: + +- **Focal point**: What should be the hero moment? (Pick ONE, make it amazing) +- **Personality direction**: Maximalist chaos? Elegant drama? Playful energy? Dark moody? Choose a lane. +- **Risk budget**: How experimental can we be? Push boundaries within constraints. +- **Hierarchy amplification**: Make big things BIGGER, small things smaller (increase contrast) + +**IMPORTANT**: Bold design must still be usable. Impact without function is just decoration. + +## Amplify the Design + +Systematically increase impact across these dimensions: + +### Typography Amplification +- **Replace generic fonts**: Swap system fonts for distinctive choices (see the parent skill's typography guidelines and [typography.md](typography.md) for inspiration) +- **Extreme scale**: Create dramatic size jumps (3x-5x differences, not 1.5x) +- **Weight contrast**: Pair 900 weights with 200 weights, not 600 with 400 +- **Unexpected choices**: Variable fonts, display fonts for headlines, condensed/extended widths, monospace as intentional accent (not as lazy "dev tool" default) + +### Color Intensification +- **Increase saturation**: Shift to more vibrant, energetic colors (but not neon) +- **Bold palette**: Introduce unexpected color combinations. Avoid the purple-blue gradient AI slop +- **Dominant color strategy**: Let one bold color own 60% of the design +- **Sharp accents**: High-contrast accent colors that pop +- **Tinted neutrals**: Replace pure grays with tinted grays that harmonize with your palette +- **Rich gradients**: Intentional multi-stop gradients (not generic purple-to-blue) + +### Spatial Drama +- **Extreme scale jumps**: Make important elements 3-5x larger than surroundings +- **Break the grid**: Let hero elements escape containers and cross boundaries +- **Asymmetric layouts**: Replace centered, balanced layouts with tension-filled asymmetry +- **Generous space**: Use white space dramatically (100-200px gaps, not 20-40px) +- **Overlap**: Layer elements intentionally for depth + +### Visual Effects +- **Dramatic shadows**: Large, soft shadows for elevation (but not generic drop shadows on rounded rectangles) +- **Background treatments**: Mesh patterns, noise textures, geometric patterns, intentional gradients (not purple-to-blue) +- **Texture & depth**: Grain, halftone, duotone, layered elements. NOT glassmorphism (it's overused AI slop) +- **Borders & frames**: Thick borders, decorative frames, custom shapes (not rounded rectangles with colored border on one side) +- **Custom elements**: Illustrative elements, custom icons, decorative details that reinforce brand + +### Motion & Animation +- **Entrance choreography**: Staggered, dramatic page load animations with 50-100ms delays +- **Scroll effects**: Parallax, reveal animations, scroll-triggered sequences +- **Micro-interactions**: Satisfying hover effects, click feedback, state changes +- **Transitions**: Smooth, noticeable transitions using ease-out-quart/quint/expo (not bounce or elastic, which cheapen the effect) + +### Composition Boldness +- **Hero moments**: Create clear focal points with dramatic treatment +- **Diagonal flows**: Escape horizontal/vertical rigidity with diagonal arrangements +- **Full-bleed elements**: Use full viewport width/height for impact +- **Unexpected proportions**: Golden ratio? Throw it out. Try 70/30, 80/20 splits + +**NEVER**: +- Add effects randomly without purpose (chaos ≠ bold) +- Sacrifice readability for aesthetics (body text must be readable) +- Make everything bold (then nothing is bold; you need contrast) +- Ignore accessibility (bold design must still meet WCAG standards) +- Overwhelm with motion (animation fatigue is real) +- Copy trendy aesthetics blindly (bold means distinctive, not derivative) + +## Verify Quality + +Ensure amplification maintains usability and coherence: + +- **NOT AI slop**: Does this look like every other AI-generated "bold" design? If yes, start over. +- **Still functional**: Can users accomplish tasks without distraction? +- **Coherent**: Does everything feel intentional and unified? +- **Memorable**: Will users remember this experience? +- **Performant**: Do all these effects run smoothly? +- **Accessible**: Does it still meet accessibility standards? + +**The test**: If you showed this to someone and said "AI made this bolder," would they believe you immediately? If yes, you've failed. Bold means distinctive, not "more AI effects." + +When the result feels right, hand off to `$impeccable polish` for the final pass. diff --git a/.agents/skills/impeccable/reference/brand.md b/.agents/skills/impeccable/reference/brand.md new file mode 100644 index 00000000..3d83a1cd --- /dev/null +++ b/.agents/skills/impeccable/reference/brand.md @@ -0,0 +1,118 @@ +# Brand register + +When design IS the product: brand sites, landing pages, marketing surfaces, campaign pages, portfolios, long-form content, about pages. The deliverable is the design itself; a visitor's impression is the thing being made. + +The register spans every genre. A tech brand (Stripe, Linear, Vercel). A luxury brand (a hotel, a fashion house). A consumer product (a restaurant, a travel site, a CPG packaging page). A creative studio, an agency portfolio, a band's album page. They all share the stance (*communicate, not transact*) and diverge wildly in aesthetic. Don't collapse them into a single look. + +## The brand slop test + +If someone could look at this and say "AI made that" without hesitation, it's failed. The bar is distinctiveness; a visitor should ask "how was this made?", not "which AI made this?" + +Brand isn't a neutral register. AI-generated landing pages have flooded the internet, and average is no longer findable. Restraint without intent now reads as mediocre, not refined. Brand surfaces need a POV, a specific audience, a willingness to risk strangeness. Go big or go home. + +**The second slop test: aesthetic lane.** Before committing to moves, name the reference. A Klim-style specimen page is one lane; Stripe-minimal is another; Liquid-Death-acid-maximalism is another. Don't drift into editorial-magazine aesthetics on a brief that isn't editorial. A hiking brand with Cormorant italic drop caps has the wrong register within the register. + +Then the inverse test: in one sentence, describe what you're about to build the way a competitor would describe theirs. If that sentence fits the modal landing page in the category, restart. + +## Typography + +### Font selection procedure + +Every project. Never skip. + +1. Read the brief. Write three concrete brand-voice words. Not "modern" or "elegant," but "warm and mechanical and opinionated" or "calm and clinical and careful." Physical-object words. +2. List the three fonts you'd reach for by reflex. If any appear in the reflex-reject list below, reject them; they are training-data defaults and they create monoculture. +3. Browse a real catalog (Google Fonts, Pangram Pangram, Future Fonts, Adobe Fonts, ABC Dinamo, Klim, Velvetyne) with the three words in mind. Find the font for the brand as a *physical object*: a museum caption, a 1970s terminal manual, a fabric label, a cheap-newsprint children's book, a concert poster, a receipt from a mid-century diner. Reject the first thing that "looks designy." +4. Cross-check. "Elegant" is not necessarily serif. "Technical" is not necessarily sans. "Warm" is not Fraunces. If the final pick lines up with the original reflex, start over. + +### Reflex-reject list + +Training-data defaults. Ban list. Look further: + +Fraunces · Newsreader · Lora · Crimson · Crimson Pro · Crimson Text · Playfair Display · Cormorant · Cormorant Garamond · Syne · IBM Plex Mono · IBM Plex Sans · IBM Plex Serif · Space Mono · Space Grotesk · Inter · DM Sans · DM Serif Display · DM Serif Text · Outfit · Plus Jakarta Sans · Instrument Sans · Instrument Serif + +### Reflex-reject aesthetic lanes + +Parallel to the font list. Currently saturated aesthetic families that have flooded brand surfaces. If a brief lands in one of these lanes without a register reason that *requires* it (a literal magazine, a literal terminal, a literal industrial signage system), it's the second-order training reflex: the trap one tier deeper than picking a Fraunces font. Look further. + +- **Editorial-typographic.** Display serif (often italic) + small mono labels + ruled separators + monochromatic restraint. Klim-influenced, magazine-cover affectation. By 2026, every Stripe-adjacent and Notion-adjacent brand has landed here. The fingerprint: three rule-separated columns, an italic Fraunces / Recoleta / Newsreader headline, lowercase track-spaced metadata, no imagery. + +(More entries land here on the same cadence the font list updates. Brutalist-utility and acid-maximalism may join when they saturate. Removing entries when they fall back below saturation is also fine.) + +The reflex-reject lists apply to **new design choices**. When the existing brand has already committed to a font or a lane as part of its identity, identity-preservation wins; variants on an existing surface don't second-guess what's already shipping. The reflex-reject lists are for greenfield decisions and for departure-mode variants in [live.md](live.md). + +### Pairing and voice + +Distinctive + refined is the goal. The specific shape depends on the brand: + +- **Editorial / long-form / luxury**: display serif + sans body (a magazine shape). +- **Tech / dev tools / fintech**: one committed sans, usually; custom-tight tracking, strong weight contrast inside a single family. +- **Consumer / food / travel**: warmer pairings, often a humanist sans plus a script or display serif. +- **Creative studios / agencies**: rule-breaking welcome. Mono-only, or display-only, or custom-drawn type as voice. + +Two families minimum is the rule *only* when the voice needs it. A single well-chosen family with committed weight/size contrast is stronger than a timid display+body pair. + +Vary across projects. If the last brief was a serif-display landing page, this one isn't. + +### Scale + +Modular scale, fluid `clamp()` for headings, ≥1.25 ratio between steps. Flat scales (1.1× apart) read as uncommitted. + +Light text on dark backgrounds: add 0.05–0.1 to line-height. Light type reads as lighter weight and needs more breathing room. + +## Color + +Brand surfaces have permission for Committed, Full palette, and Drenched strategies. Use them. A single saturated color spread across a hero is not excess; it's voice. A beige-and-muted-slate landing page ignores the register. + +- Name a real reference before picking a strategy. "Klim Type Foundry #ff4500 orange drench", "Stripe purple-on-white restraint", "Liquid Death acid-green full palette", "Mailchimp yellow full palette", "Condé Nast Traveler muted navy restraint", "Vercel pure black monochrome". Unnamed ambition becomes beige. +- Palette IS voice. A calm brand and a restless brand should not share palette mechanics. +- When the strategy is Committed or Drenched, color carries the brand. Don't hedge with neutrals around the edges. Commit. +- Don't converge across projects. If the last brand surface was restrained-on-cream, this one is not. +- When a cultural-symbol palette is the obvious pull, reach past it. Let the cultural reading come from typography, imagery, and copy, not the palette. + +## Layout + +- Asymmetric compositions are one option. Break the grid intentionally for emphasis. +- Fluid spacing with `clamp()` that breathes on larger viewports. Vary for rhythm: generous separations, tight groupings. +- Alternative: a strict, visible grid as the voice (brutalist / Swiss / tech-spec aesthetics). Either asymmetric or rigorously-gridded can be "designed"; the failure mode is splitting the difference into a generic centered stack. +- Don't default to centering everything. Left-aligned with asymmetric layouts feels more designed; a strict grid reads as confident structure. A centered-stack hero with icon-title-subtitle cards reads as template. +- When cards ARE the right affordance, use `grid-template-columns: repeat(auto-fit, minmax(280px, 1fr))` for breakpoint-free responsiveness. + +## Imagery + +Brand surfaces lean on imagery. A restaurant, hotel, magazine, or product landing page without any imagery reads as incomplete, not as restrained. A solid-color rectangle where a hero image should go is worse than a representative stock photo. + +**When the brief implies imagery (restaurants, hotels, magazines, photography, hobbyist communities, food, travel, fashion, product), you must ship imagery.** Zero images is a bug, not a design choice. "Restraint" is not an excuse. If the approved comp or brief is image-led, ship real project assets, generated raster assets, or a credible canvas/SVG/WebGL scene. Do not replace photographic, architectural, product, or place imagery with generic CSS panels, decorative diagrams, cards, bullets, or copy. + +- **For greenfield work without local assets, use stock imagery.** Unsplash is the default. The URL shape is `https://images.unsplash.com/photo-{id}?auto=format&fit=crop&w=1600&q=80`. **Verify the URLs before referencing them.** If you have an image-search MCP, web-fetch tool, or browser access, use it to find real photo IDs and confirm they resolve. Guessed IDs (even ones that look real) often 404 and ship as broken-image placeholders. Without a verification path, pick fewer photos you're confident exist over more that you guessed; never substitute colored `
` placeholders. +- **Search for the brand's physical object**, not the generic category: "handmade pasta on a scratched wooden table" beats "Italian food"; "cypress trees above a limestone hotel facade at dusk" beats "luxury hotel". +- **One decisive photo beats five mediocre ones.** Hero imagery should commit to a mood; padding with more stock doesn't rescue an indecisive one. +- **Alt text is part of the voice.** "Coastal fettuccine, hand-cut, served on the terrace" beats "pasta dish". + +"Imagery" here is broader than stock photography: product screenshots, custom data visualizations, generated SVG, and canvas/WebGL scenes are all imagery. Text-only pages where typography alone carries the entire visual weight are the failure mode. + +## Motion + +- One well-orchestrated page-load with staggered reveals beats scattered micro-interactions, when the brand invites it. Tech-minimal brands often skip entrance motion entirely; the restraint is the voice. +- For collapsing/expanding sections, transition `grid-template-rows` rather than `height`. + +## Brand bans (on top of the shared absolute bans) + +- Monospace as lazy shorthand for "technical / developer." If the brand isn't technical, mono reads as costume. +- Large rounded-corner icons above every heading. Screams template. +- Single-family pages that picked the family by reflex, not voice. (A single family chosen deliberately is fine.) +- All-caps body copy. Reserve caps for short labels and headings. +- Timid palettes and average layouts. Safe = invisible. +- Zero imagery on a brief that implies imagery (restaurant, hotel, food, travel, fashion, photography, hobbyist). Colored blocks where a hero photo belongs. +- Defaulting to editorial-magazine aesthetics (display serif + italic + drop caps + broadsheet grid) on briefs that aren't magazine-shaped. Editorial is ONE aesthetic lane, not the default brand aesthetic. +- Repeated tiny uppercase tracked labels above every section heading. A single strong kicker can be voice; repeating it as section grammar is AI scaffolding unless it's a deliberate, named brand system. + +## Brand permissions + +Brand can afford things product can't. Take them. + +- Ambitious first-load motion. Reveals, scroll-triggered transitions, typographic choreography. +- Single-purpose viewports. One dominant idea per fold, long scroll, deliberate pacing. +- Typographic risk. Enormous display type, unexpected italic cuts, mixed cases, hand-drawn headlines, a single oversize word as a hero. +- Unexpected color strategies. Palette IS voice; a calm brand and a restless brand should not share palette mechanics. +- Art direction per section. Different sections can have different visual worlds if the narrative demands it. Consistency of voice beats consistency of treatment. diff --git a/.agents/skills/impeccable/reference/clarify.md b/.agents/skills/impeccable/reference/clarify.md new file mode 100644 index 00000000..07b9d8d2 --- /dev/null +++ b/.agents/skills/impeccable/reference/clarify.md @@ -0,0 +1,174 @@ +> **Additional context needed**: audience technical level and users' mental state in context. + +Find the unclear, confusing, or poorly written interface text and rewrite it. Vague copy creates support tickets and abandonment; specific copy gets users through the task. + + +--- + +## Assess Current Copy + +Identify what makes the text unclear or ineffective: + +1. **Find clarity problems**: + - **Jargon**: Technical terms users won't understand + - **Ambiguity**: Multiple interpretations possible + - **Passive voice**: "Your file has been uploaded" vs "We uploaded your file" + - **Length**: Too wordy or too terse + - **Assumptions**: Assuming user knowledge they don't have + - **Missing context**: Users don't know what to do or why + - **Tone mismatch**: Too formal, too casual, or inappropriate for situation + +2. **Understand the context**: + - Who's the audience? (Technical? General? First-time users?) + - What's the user's mental state? (Stressed during error? Confident during success?) + - What's the action? (What do we want users to do?) + - What's the constraint? (Character limits? Space limitations?) + +**CRITICAL**: Clear copy helps users succeed. Unclear copy creates frustration, errors, and support tickets. + +## Plan Copy Improvements + +Create a strategy for clearer communication: + +- **Primary message**: What's the ONE thing users need to know? +- **Action needed**: What should users do next (if anything)? +- **Tone**: How should this feel? (Helpful? Apologetic? Encouraging?) +- **Constraints**: Length limits, brand voice, localization considerations + +**IMPORTANT**: Good UX writing is invisible. Users should understand immediately without noticing the words. + +## Improve Copy Systematically + +Refine text across these common areas: + +### Error Messages +**Bad**: "Error 403: Forbidden" +**Good**: "You don't have permission to view this page. Contact your admin for access." + +**Bad**: "Invalid input" +**Good**: "Email addresses need an @ symbol. Try: name@example.com" + +**Principles**: +- Explain what went wrong in plain language +- Suggest how to fix it +- Don't blame the user +- Include examples when helpful +- Link to help/support if applicable + +### Form Labels & Instructions +**Bad**: "DOB (MM/DD/YYYY)" +**Good**: "Date of birth" (with placeholder showing format) + +**Bad**: "Enter value here" +**Good**: "Your email address" or "Company name" + +**Principles**: +- Use clear, specific labels (not generic placeholders) +- Show format expectations with examples +- Explain why you're asking (when not obvious) +- Put instructions before the field, not after +- Keep required field indicators clear + +### Button & CTA Text +**Bad**: "Click here" | "Submit" | "OK" +**Good**: "Create account" | "Save changes" | "Got it, thanks" + +**Principles**: +- Describe the action specifically +- Use active voice (verb + noun) +- Match user's mental model +- Be specific ("Save" is better than "OK") + +### Help Text & Tooltips +**Bad**: "This is the username field" +**Good**: "Choose a username. You can change this later in Settings." + +**Principles**: +- Add value (don't just repeat the label) +- Answer the implicit question ("What is this?" or "Why do you need this?") +- Keep it brief but complete +- Link to detailed docs if needed + +### Empty States +**Bad**: "No items" +**Good**: "No projects yet. Create your first project to get started." + +**Principles**: +- Explain why it's empty (if not obvious) +- Show next action clearly +- Make it welcoming, not dead-end + +### Success Messages +**Bad**: "Success" +**Good**: "Settings saved! Your changes will take effect immediately." + +**Principles**: +- Confirm what happened +- Explain what happens next (if relevant) +- Be brief but complete +- Match the user's emotional moment (celebrate big wins) + +### Loading States +**Bad**: "Loading..." (for 30+ seconds) +**Good**: "Analyzing your data... this usually takes 30-60 seconds" + +**Principles**: +- Set expectations (how long?) +- Explain what's happening (when it's not obvious) +- Show progress when possible +- Offer escape hatch if appropriate ("Cancel") + +### Confirmation Dialogs +**Bad**: "Are you sure?" +**Good**: "Delete 'Project Alpha'? This can't be undone." + +**Principles**: +- State the specific action +- Explain consequences (especially for destructive actions) +- Use clear button labels ("Delete project" not "Yes") +- Don't overuse confirmations (only for risky actions) + +### Navigation & Wayfinding +**Bad**: Generic labels like "Items" | "Things" | "Stuff" +**Good**: Specific labels like "Your projects" | "Team members" | "Settings" + +**Principles**: +- Be specific and descriptive +- Use language users understand (not internal jargon) +- Make hierarchy clear +- Consider information scent (breadcrumbs, current location) + +## Apply Clarity Principles + +Every piece of copy should follow these rules: + +1. **Be specific**: "Enter email" not "Enter value" +2. **Be concise**: Cut unnecessary words (but don't sacrifice clarity) +3. **Be active**: "Save changes" not "Changes will be saved" +4. **Be human**: "Oops, something went wrong" not "System error encountered" +5. **Tell users what to do**, not just what happened +6. **Be consistent**: Use same terms throughout (don't vary for variety) + +**NEVER**: +- Use jargon without explanation +- Blame users ("You made an error" → "This field is required") +- Be vague ("Something went wrong" without explanation) +- Use passive voice unnecessarily +- Write overly long explanations (be concise) +- Use humor for errors (be empathetic instead) +- Assume technical knowledge +- Vary terminology (pick one term and stick with it) +- Repeat information (headers restating intros, redundant explanations) +- Use placeholders as the only labels (they disappear when users type) + +## Verify Improvements + +Test that copy improvements work: + +- **Comprehension**: Can users understand without context? +- **Actionability**: Do users know what to do next? +- **Brevity**: Is it as short as possible while remaining clear? +- **Consistency**: Does it match terminology elsewhere? +- **Tone**: Is it appropriate for the situation? + +When the copy reads cleanly, hand off to `$impeccable polish` for the final pass. diff --git a/.agents/skills/impeccable/reference/codex.md b/.agents/skills/impeccable/reference/codex.md new file mode 100644 index 00000000..0b35f3e3 --- /dev/null +++ b/.agents/skills/impeccable/reference/codex.md @@ -0,0 +1,105 @@ +# Codex: Visual Direction & Asset Production + +This file is loaded by `$impeccable craft` when the harness has native image generation (currently Codex via `image_gen`). Other harnesses skip it. It covers the two craft steps that depend on real image generation: landing the visual direction, and producing the raster assets the implementation will compose. + +Read this *before* generating any images. The order matters, and the per-step user pauses are what keep generated imagery from drifting away from the brief. + +### Four stop points before code + +Steps A through D each end with the user. Do not advance past any of them on your own read of the situation. + +1. **STOP after Step A questions.** Wait for answers. +2. **STOP after Step B palette generation.** Wait for "confirm palette." +3. **STOP after Step C mocks.** Wait for direction approval or delegation. +4. **Only after Step D approves a direction** do you return to craft.md Step 4 and write code. + +Prior shape approval does **not** satisfy any of these. Shape's "confirm or override" advances you into Step A; it is not a substitute for it. + +## Step A: Explore Directions with the User + +Before generating anything, run a brief direction conversation grounded in the shape brief. + +**Step A is required even when shape just produced a confirmed brief.** The shape questions and Step A questions cover different ground: shape pins purpose, content, scope; Step A pins palette, atmosphere, and named visual references for the comps you're about to generate. The only time you can skip Step A is when the user has already answered these exact palette/atmosphere/reference questions in the same session. + +Ask **2-3 targeted questions** about visual lane, color strategy, atmosphere, and named anchor references. Don't enumerate generic menus; tie each question to the shape brief's answers. Example shape-grounded questions: + +- "Brief says 'editorial restraint, Klim-adjacent.' Are we closer to a quiet specimen page or a magazine-spread feel with hero imagery?" +- "Palette strategy from shape was 'Committed.' Want it warm-grounded (deep oxblood + cream) or cool-grounded (slate + paper white)?" + +**STOP and wait for answers.** These pin the palette before any pixel gets generated. Do not proceed to Step B until the user has responded. + +## Step B: Generate the Brand Palette First + +Generate **one** palette artifact before any mocks. This is a small, focused image: typography pairing on the chosen background, primary + accent color swatches, one signature ornament or motif. Single image, single pass. + +Why palette first: mocks generated against a vague color sense produce noise that drowns out the structural decisions. A confirmed palette is the first concrete contract for everything downstream. + +Show the palette to the user. Ask one question: "This is the palette I'm locking in for the mocks. Confirm, or call out what to shift?" + +**STOP and wait for confirmation.** Do not generate mocks against an unconfirmed palette. "Probably good enough" is the wrong call here; the palette is the contract for everything downstream. + +## Step C: Generate 1-3 Visual Mocks Against the Palette + +Once the palette is confirmed, generate **1 to 3** high-fidelity north-star comps. Each mock must use the confirmed palette and typography. Mocks differ in *structural* direction (hierarchy, topology, density, composition), not in color or motif. + +- Brand work: push visual identity, composition, mood, and signature motifs. +- Product work: push hierarchy, topology, density, tone, grounded in realistic product structure. +- Landing pages and long-form brand surfaces: show enough of the second fold to establish the system beyond the hero. + +Use the `image_gen` tool directly (or via the imagegen skill when available). Don't ask the user to install anything. + +## Step D: Approval Loop + +Show the comps. Ask what carries forward. Iterate until **one direction is approved** or the user explicitly delegates. + +**STOP and wait for the approval or the delegation.** Do not begin Step E or return to craft.md Step 4 until a single direction is named. If the user delegates, pick the strongest direction and explain it from the brief, not personal taste. + +Before moving to assets, summarize what to carry into code and what *not* to literalize from the mock. This is the handoff between visual exploration and semantic implementation. + +## Step E: Mock Fidelity Inventory + +Inventory the approved mock's major visible ingredients. For each, decide implementation: semantic HTML/CSS/SVG, generated raster, sourced raster, icon library, canvas/WebGL, or accepted omission. + +Common ingredients to inventory: + +- Hero silhouette and dominant composition +- Signature motifs (planets, devices, portraits, charts, route lines, insets, badges, etc.) +- Nav and primary CTA treatment +- Section sequence, especially the second fold +- Image-native content the concept depends on +- Typography, density, color/material treatment, motion cues + +Treat the mock as a north star, not a screenshot to trace. Don't rasterize core UI text. But if the live result lacks the mock's major ingredients, the implementation is wrong. + +If a photographic, architectural, product, or place-led mock becomes generic CSS scenery, decorative diagrams, bullets, or copy, stop and fix it. That's a broken implementation, not a harmless interpretation. + +Don't substitute a different hero composition or visual driver post-approval without user sign-off. + +## Step F: Asset Slicing via the Asset Producer + +Raster ingredients identified in Step E need clean production assets. Use the bundled `impeccable_asset_producer` subagent rather than producing inline. + +Spawn it as a scoped subagent. If you do not have explicit permission to use agents, stop and ask: + +```text +Asset production will work better as a scoped subagent job. Should I spawn the Impeccable asset producer subagent for this step? +``` + +Pass to the agent: + +- Approved mock path or screenshot reference +- Crop paths or a contact sheet with crop ids +- Output directory +- Required dimensions, format, transparency needs +- Avoid list +- Notes on what should remain semantic HTML/CSS/SVG instead of raster + +Attach image generation capability to the spawned agent when the harness supports it. Do **not** load image-generation reference material into the parent thread. + +Inline asset production is allowed only if the user declines subagents, the harness cannot spawn the authorized agent, or the user explicitly asks for single-thread mode. + +Prefer HTML/CSS/SVG/canvas when they can credibly reproduce an ingredient; reach for real, generated, or stock imagery when the mock or subject matter calls for actual visual content. + +## After This File + +Once Steps A through F are complete, return to `craft.md` Step 5 (Build to Production Quality). The implementation builds against the confirmed palette, approved mock, and the assets the producer wrote. diff --git a/.agents/skills/impeccable/reference/cognitive-load.md b/.agents/skills/impeccable/reference/cognitive-load.md new file mode 100644 index 00000000..48f8ad58 --- /dev/null +++ b/.agents/skills/impeccable/reference/cognitive-load.md @@ -0,0 +1,106 @@ +# Cognitive Load Assessment + +Cognitive load is the total mental effort required to use an interface. Overloaded users make mistakes, get frustrated, and leave. This reference helps identify and fix cognitive overload. + +--- + +## Three Types of Cognitive Load + +### Intrinsic Load: The Task Itself +Complexity inherent to what the user is trying to do. You can't eliminate this, but you can structure it. + +**Manage it by**: +- Breaking complex tasks into discrete steps +- Providing scaffolding (templates, defaults, examples) +- Progressive disclosure: show what's needed now, hide the rest +- Grouping related decisions together + +### Extraneous Load: Bad Design +Mental effort caused by poor design choices. **Eliminate this ruthlessly.** It's pure waste. + +**Common sources**: +- Confusing navigation that requires mental mapping +- Unclear labels that force users to guess meaning +- Visual clutter competing for attention +- Inconsistent patterns that prevent learning +- Unnecessary steps between user intent and result + +### Germane Load: Learning Effort +Mental effort spent building understanding. This is *good* cognitive load; it leads to mastery. + +**Support it by**: +- Progressive disclosure that reveals complexity gradually +- Consistent patterns that reward learning +- Feedback that confirms correct understanding +- Onboarding that teaches through action, not walls of text + +--- + +## Cognitive Load Checklist + +Evaluate the interface against these 8 items: + +- [ ] **Single focus**: Can the user complete their primary task without distraction from competing elements? +- [ ] **Chunking**: Is information presented in digestible groups (≤4 items per group)? +- [ ] **Grouping**: Are related items visually grouped together (proximity, borders, shared background)? +- [ ] **Visual hierarchy**: Is it immediately clear what's most important on the screen? +- [ ] **One thing at a time**: Can the user focus on a single decision before moving to the next? +- [ ] **Minimal choices**: Are decisions simplified (≤4 visible options at any decision point)? +- [ ] **Working memory**: Does the user need to remember information from a previous screen to act on the current one? +- [ ] **Progressive disclosure**: Is complexity revealed only when the user needs it? + +**Scoring**: Count the failed items. 0–1 failures = low cognitive load (good). 2–3 = moderate (address soon). 4+ = high cognitive load (critical fix needed). + +--- + +## The Working Memory Rule + +**Humans can hold ≤4 items in working memory at once** (Miller's Law revised by Cowan, 2001). + +At any decision point, count the number of distinct options, actions, or pieces of information a user must simultaneously consider: +- **≤4 items**: Within working memory limits, manageable +- **5–7 items**: Pushing the boundary; consider grouping or progressive disclosure +- **8+ items**: Overloaded; users will skip, misclick, or abandon + +**Practical applications**: +- Navigation menus: ≤5 top-level items (group the rest under clear categories) +- Form sections: ≤4 fields visible per group before a visual break +- Action buttons: 1 primary, 1–2 secondary, group the rest in a menu +- Dashboard widgets: ≤4 key metrics visible without scrolling +- Pricing tiers: ≤3 options (more causes analysis paralysis) + +--- + +## Common Cognitive Load Violations + +### 1. The Wall of Options +**Problem**: Presenting 10+ choices at once with no hierarchy. +**Fix**: Group into categories, highlight recommended, use progressive disclosure. + +### 2. The Memory Bridge +**Problem**: User must remember info from step 1 to complete step 3. +**Fix**: Keep relevant context visible, or repeat it where it's needed. + +### 3. The Hidden Navigation +**Problem**: User must build a mental map of where things are. +**Fix**: Always show current location (breadcrumbs, active states, progress indicators). + +### 4. The Jargon Barrier +**Problem**: Technical or domain language forces translation effort. +**Fix**: Use plain language. If domain terms are unavoidable, define them inline. + +### 5. The Visual Noise Floor +**Problem**: Every element has the same visual weight; nothing stands out. +**Fix**: Establish clear hierarchy: one primary element, 2–3 secondary, everything else muted. + +### 6. The Inconsistent Pattern +**Problem**: Similar actions work differently in different places. +**Fix**: Standardize interaction patterns. Same type of action = same type of UI. + +### 7. The Multi-Task Demand +**Problem**: Interface requires processing multiple simultaneous inputs (reading + deciding + navigating). +**Fix**: Sequence the steps. Let the user do one thing at a time. + +### 8. The Context Switch +**Problem**: User must jump between screens/tabs/modals to gather info for a single decision. +**Fix**: Co-locate the information needed for each decision. Reduce back-and-forth. diff --git a/.agents/skills/impeccable/reference/color-and-contrast.md b/.agents/skills/impeccable/reference/color-and-contrast.md new file mode 100644 index 00000000..110c2ee4 --- /dev/null +++ b/.agents/skills/impeccable/reference/color-and-contrast.md @@ -0,0 +1,105 @@ +# Color & Contrast + +## Color Spaces: Use OKLCH + +**Stop using HSL.** Use OKLCH (or LCH) instead. It's perceptually uniform, meaning equal steps in lightness *look* equal, unlike HSL where 50% lightness in yellow looks bright while 50% in blue looks dark. + +The OKLCH function takes three components: `oklch(lightness chroma hue)` where lightness is 0-100%, chroma is roughly 0-0.4, and hue is 0-360. To build a primary color and its lighter / darker variants, hold the chroma+hue roughly constant and vary the lightness, but **reduce chroma as you approach white or black**, because high chroma at extreme lightness looks garish. + +The hue you pick is a brand decision and should not come from a default. Do not reach for blue (hue 250) or warm orange (hue 60) by reflex; those are the dominant AI-design defaults, not the right answer for any specific brand. + +## Building Functional Palettes + +### Tinted Neutrals + +**Pure gray is dead.** A neutral with zero chroma feels lifeless next to a colored brand. Add a tiny chroma value (0.005-0.015) to all your neutrals, hued toward whatever your brand color is. The chroma is small enough not to read as "tinted" consciously, but it creates subconscious cohesion between brand color and UI surfaces. + +The hue you tint toward should come from THIS project's brand, not from a "warm = friendly, cool = tech" formula. If your brand color is teal, your neutrals lean toward teal. If your brand color is amber, they lean toward amber. The point is cohesion with the SPECIFIC brand, not a stock palette. + +**Avoid** the trap of always tinting toward warm orange or always tinting toward cool blue. Those are the two laziest defaults and they create their own monoculture across projects. + +### Palette Structure + +A complete system needs: + +| Role | Purpose | Example | +|------|---------|---------| +| **Primary** | Brand, CTAs, key actions | 1 color, 3-5 shades | +| **Neutral** | Text, backgrounds, borders | 9-11 shade scale | +| **Semantic** | Success, error, warning, info | 4 colors, 2-3 shades each | +| **Surface** | Cards, modals, overlays | 2-3 elevation levels | + +**Skip secondary/tertiary unless you need them.** Most apps work fine with one accent color. Adding more creates decision fatigue and visual noise. + +### The 60-30-10 Rule (Applied Correctly) + +This rule is about **visual weight**, not pixel count: + +- **60%**: Neutral backgrounds, white space, base surfaces +- **30%**: Secondary colors: text, borders, inactive states +- **10%**: Accent: CTAs, highlights, focus states + +The common mistake: using the accent color everywhere because it's "the brand color." Accent colors work *because* they're rare. Overuse kills their power. + +## Contrast & Accessibility + +### WCAG Requirements + +| Content Type | AA Minimum | AAA Target | +|--------------|------------|------------| +| Body text | 4.5:1 | 7:1 | +| Large text (18px+ or 14px bold) | 3:1 | 4.5:1 | +| UI components, icons | 3:1 | 4.5:1 | +| Non-essential decorations | None | None | + +**The gotcha**: Placeholder text still needs 4.5:1. That light gray placeholder you see everywhere? Usually fails WCAG. + +### Dangerous Color Combinations + +These commonly fail contrast or cause readability issues: + +- Light gray text on white (the #1 accessibility fail) +- **Gray text on any colored background**: gray looks washed out and dead on color. Use a darker shade of the background color, or transparency +- Red text on green background (or vice versa): 8% of men can't distinguish these +- Blue text on red background (vibrates visually) +- Yellow text on white (almost always fails) +- Thin light text on images (unpredictable contrast) + +### Never Use Pure Gray or Pure Black + +Pure gray (`oklch(50% 0 0)`) and pure black (`#000`) don't exist in nature; real shadows and surfaces always have a color cast. Even a chroma of 0.005-0.01 is enough to feel natural without being obviously tinted. (See tinted neutrals example above.) + +### Testing + +Don't trust your eyes. Use tools: + +- [WebAIM Contrast Checker](https://webaim.org/resources/contrastchecker/) +- Browser DevTools → Rendering → Emulate vision deficiencies +- [Polypane](https://polypane.app/) for real-time testing + +## Theming: Light & Dark Mode + +### Dark Mode Is Not Inverted Light Mode + +You can't just swap colors. Dark mode requires different design decisions: + +| Light Mode | Dark Mode | +|------------|-----------| +| Shadows for depth | Lighter surfaces for depth (no shadows) | +| Dark text on light | Light text on dark (reduce font weight) | +| Vibrant accents | Desaturate accents slightly | +| White backgrounds | Never pure black; use dark gray (oklch 12-18%) | + +In dark mode, depth comes from surface lightness, not shadow. Build a 3-step surface scale where higher elevations are lighter (e.g. 15% / 20% / 25% lightness). Use the SAME hue and chroma as your brand color (whatever it is for THIS project; do not reach for blue) and only vary the lightness. Reduce body text weight slightly (e.g. 350 instead of 400) because light text on dark reads as heavier than dark text on light. + +### Token Hierarchy + +Use two layers: primitive tokens (`--blue-500`) and semantic tokens (`--color-primary: var(--blue-500)`). For dark mode, only redefine the semantic layer; primitives stay the same. + +## Alpha Is A Design Smell + +Heavy use of transparency (rgba, hsla) usually means an incomplete palette. Alpha creates unpredictable contrast, performance overhead, and inconsistency. Define explicit overlay colors for each context instead. Exception: focus rings and interactive states where see-through is needed. + +--- + +**Avoid**: Relying on color alone to convey information. Creating palettes without clear roles for each color. Using pure black (#000) for large areas. Skipping color blindness testing (8% of men affected). diff --git a/.agents/skills/impeccable/reference/colorize.md b/.agents/skills/impeccable/reference/colorize.md new file mode 100644 index 00000000..a6ddfb29 --- /dev/null +++ b/.agents/skills/impeccable/reference/colorize.md @@ -0,0 +1,154 @@ +> **Additional context needed**: existing brand colors. + +Replace timid grayscale or single-accent designs with a strategic palette: pick a color strategy, choose a hue family that fits the brand, then apply color with intent. More color ≠ better. Strategic color beats rainbow vomit. + +--- + +## Register + +Brand: palette IS voice. Pick a color strategy first per SKILL.md (Restrained / Committed / Full palette / Drenched) and follow its dosage. Committed, Full palette, and Drenched deliberately exceed the ≤10% rule; that rule is Restrained only. Unexpected combinations are allowed; a dominant color can own the page when the chosen strategy calls for it. + +Product: semantic-first and almost always Restrained. Accent color is reserved for primary action, current selection, and state indicators. Not decoration. Every color has a consistent meaning across every screen. + +--- + +## Assess Color Opportunity + +Analyze the current state and identify opportunities: + +1. **Understand current state**: + - **Color absence**: Pure grayscale? Limited neutrals? One timid accent? + - **Missed opportunities**: Where could color add meaning, hierarchy, or delight? + - **Context**: What's appropriate for this domain and audience? + - **Brand**: Are there existing brand colors we should use? + +2. **Identify where color adds value**: + - **Semantic meaning**: Success (green), error (red), warning (yellow/orange), info (blue) + - **Hierarchy**: Drawing attention to important elements + - **Categorization**: Different sections, types, or states + - **Emotional tone**: Warmth, energy, trust, creativity + - **Wayfinding**: Helping users navigate and understand structure + - **Delight**: Moments of visual interest and personality + +If any of these are unclear from the codebase, STOP and use Codex's structured user-input/question tool when available; if unavailable, ask directly in chat to clarify what you cannot infer. + +**CRITICAL**: More color ≠ better. Strategic color beats rainbow vomit every time. Every color should have a purpose. + +## Plan Color Strategy + +Create a purposeful color introduction plan: + +- **Color palette**: What colors match the brand/context? (Choose 2-4 colors max beyond neutrals) +- **Dominant color**: Which color owns 60% of colored elements? +- **Accent colors**: Which colors provide contrast and highlights? (30% and 10%) +- **Application strategy**: Where does each color appear and why? + +**IMPORTANT**: Color should enhance hierarchy and meaning, not create chaos. Less is more when it matters more. + +## Introduce Color Strategically + +Add color systematically across these dimensions: + +### Semantic Color +- **State indicators**: + - Success: Green tones (emerald, forest, mint) + - Error: Red/pink tones (rose, crimson, coral) + - Warning: Orange/amber tones + - Info: Blue tones (sky, ocean, indigo) + - Neutral: Gray/slate for inactive states + +- **Status badges**: Colored backgrounds or borders for states (active, pending, completed, etc.) +- **Progress indicators**: Colored bars, rings, or charts showing completion or health + +### Accent Color Application +- **Primary actions**: Color the most important buttons/CTAs +- **Links**: Add color to clickable text (maintain accessibility) +- **Icons**: Colorize key icons for recognition and personality +- **Headers/titles**: Add color to section headers or key labels +- **Hover states**: Introduce color on interaction + +### Background & Surfaces +- **Tinted backgrounds**: Replace pure gray (`#f5f5f5`) with warm neutrals (`oklch(97% 0.01 60)`) or cool tints (`oklch(97% 0.01 250)`) +- **Colored sections**: Use subtle background colors to separate areas +- **Gradient backgrounds**: Add depth with subtle, intentional gradients (not generic purple-blue) +- **Cards & surfaces**: Tint cards or surfaces slightly for warmth + +**Use OKLCH for color**: It's perceptually uniform, meaning equal steps in lightness *look* equal. Great for generating harmonious scales. + +### Data Visualization +- **Charts & graphs**: Use color to encode categories or values +- **Heatmaps**: Color intensity shows density or importance +- **Comparison**: Color coding for different datasets or timeframes + +### Borders & Accents +- **Hairline borders**: 1px colored borders on full perimeter (not side-stripes; see the absolute ban on `border-left/right > 1px`) +- **Underlines**: Color underlines for emphasis or active states +- **Dividers**: Subtle colored dividers instead of gray lines +- **Focus rings**: Colored focus indicators matching brand +- **Surface tints**: A 4-8% background wash of the accent color instead of a stripe + +**NEVER**: `border-left` or `border-right` greater than 1px as a colored accent stripe. This is one of the three absolute bans in the parent skill. If you want to mark a card as "active" or "warning", use a full hairline border, a background tint, a leading glyph, or a numbered prefix. Not a side stripe. + +### Typography Color +- **Colored headings**: Use brand colors for section headings (maintain contrast) +- **Highlight text**: Color for emphasis or categories +- **Labels & tags**: Small colored labels for metadata or categories + +### Decorative Elements +- **Illustrations**: Add colored illustrations or icons +- **Shapes**: Geometric shapes in brand colors as background elements +- **Gradients**: Colorful gradient overlays or mesh backgrounds +- **Blobs/organic shapes**: Soft colored shapes for visual interest + +## Balance & Refinement + +Ensure color addition improves rather than overwhelms: + +### Maintain Hierarchy +- **Dominant color** (60%): Primary brand color or most used accent +- **Secondary color** (30%): Supporting color for variety +- **Accent color** (10%): High contrast for key moments +- **Neutrals** (remaining): Gray/black/white for structure + +### Accessibility +- **Contrast ratios**: Ensure WCAG compliance (4.5:1 for text, 3:1 for UI components) +- **Don't rely on color alone**: Use icons, labels, or patterns alongside color +- **Test for color blindness**: Verify red/green combinations work for all users + +### Cohesion +- **Consistent palette**: Use colors from defined palette, not arbitrary choices +- **Systematic application**: Same color meanings throughout (green always = success) +- **Temperature consistency**: Warm palette stays warm, cool stays cool + +**NEVER**: +- Use every color in the rainbow (choose 2-4 colors beyond neutrals) +- Apply color randomly without semantic meaning +- Put gray text on colored backgrounds. It looks washed out; use a darker shade of the background color or transparency instead +- Use pure gray for neutrals. Add subtle color tint (warm or cool) for depth +- Use pure black (`#000`) or pure white (`#fff`) for large areas +- Violate WCAG contrast requirements +- Use color as the only indicator (accessibility issue) +- Make everything colorful (defeats the purpose) +- Default to purple-blue gradients (AI slop aesthetic) + +## Verify Color Addition + +Test that colorization improves the experience: + +- **Better hierarchy**: Does color guide attention appropriately? +- **Clearer meaning**: Does color help users understand states/categories? +- **More engaging**: Does the interface feel warmer and more inviting? +- **Still accessible**: Do all color combinations meet WCAG standards? +- **Not overwhelming**: Is color balanced and purposeful? + +When the palette earns its place, hand off to `$impeccable polish` for the final pass. + +## Live-mode signature params + +When invoked from live mode, each variant MUST declare a `color-amount` param so the user can dial between a restrained accent and a drenched surface without regeneration. Author the variant's CSS against `var(--p-color-amount, 0.5)`, typically as the alpha multiplier on backgrounds, or as a scaling factor on the chroma axis in an OKLCH expression. 0 = neutral/monochrome, 1 = full saturation / dominant coverage. + +```json +{"id":"color-amount","kind":"range","min":0,"max":1,"step":0.05,"default":0.5,"label":"Color amount"} +``` + +Layer 1-2 variant-specific params on top: palette selection (`steps` with named options), temperature warmth, or tint vs. true color. See `reference/live.md` for the full params contract. diff --git a/.agents/skills/impeccable/reference/craft.md b/.agents/skills/impeccable/reference/craft.md new file mode 100644 index 00000000..831b08ab --- /dev/null +++ b/.agents/skills/impeccable/reference/craft.md @@ -0,0 +1,123 @@ +# Craft Flow + +Build a feature with impeccable UX and UI quality: shape the design, land the visual direction, build real production code, inspect and improve in-browser until it meets a high-end studio bar. + +Before writing code, you need: PRODUCT.md loaded, register identified and the matching reference loaded, and a confirmed design direction for this task (either from `shape` or supplied by the user). PRODUCT.md is project context, not a task-specific brief. + +Treat any approved visual direction (generated mock or stated reference) as a concrete contract for composition, hierarchy, density, atmosphere, signature motifs, and distinctive visual moves. Don't let mocks replace structure, copy, accessibility, or state design. But if the live result lacks the approved direction's major ingredients, the implementation is wrong. + +### Gates: do not compress + +Craft has **multiple user gates**, not one. When the harness has native image generation (Codex via `image_gen`), the gate sequence before code is: + +1. **Shape brief confirmed** (Step 1) +2. **Direction questions answered** (codex.md Step A) +3. **Palette confirmed** (codex.md Step B) +4. **One mock direction approved or delegated** (codex.md Step D) + +You must stop at every gate. **Shape confirmation alone is NOT a green light to start coding.** It is the green light to begin codex.md Step A. Compressing gates 2 through 4 because the shape brief felt complete is the dominant failure mode of this flow. + +When the harness lacks native image generation, gates 2-4 collapse into the brief itself, and shape confirmation does advance straight to code. + +## Step 0: Project Foundation + +Before shape, before code: figure out what kind of project you're working in. + +Look at the working directory. Run `ls`. Check for: + +- An existing framework: `astro.config.mjs/ts`, `next.config.js/ts`, `nuxt.config.ts`, `svelte.config.js`, `vite.config.js/ts`, `package.json` with framework deps, `Cargo.toml` + Leptos/Yew, `Gemfile` + Rails. **If found, use it.** Do not start a parallel build, do not introduce a second framework, do not write to `dist/` or `build/` directly. Whatever pipeline the project has, respect it. +- An existing component library or design system: `src/components/`, `app/components/`, a `tokens.css` / `theme.ts`, an `astro.config` `integrations`. Read what's there before adding to it. +- An existing icon set: `lucide-react`, `@phosphor-icons/react`, `@iconify/*`, hand-rolled SVG sprites in `assets/icons/`. **Use what's already in the project**; don't introduce a second set. + +If the directory is empty (greenfield), don't pick a framework silently. Ask the user via the AskUserQuestion tool, with sensible defaults framed by the brief: + +```text +What should this be built on? + - Astro (default for content-led brand sites, landing pages, marketing surfaces) + - SvelteKit / Next.js / Nuxt (when the brief implies an app surface or significant interactivity) + - Single index.html (one-shot demo, prototype, or a deliberately framework-free experiment) +``` + +Default: Astro for brand briefs, the project's existing framework for product briefs. Ask once; don't re-ask mid-task. + +## Step 1: Shape the Design + +Run $impeccable shape, passing along whatever feature description the user provided. Shape is **required** for craft; it is what produces a confirmed direction. + +Present the shape output and stop. Wait for the user to confirm, override, or course-correct before writing code. + +If the user already supplied a confirmed brief or ran shape separately, use it and skip this step. + +When the original prompt + PRODUCT.md already answer scope, content, and visual direction with no real ambiguity, the shape output can be **compact** (3-5 bullets stating what you're building and the visual lane, ending with one or two specific questions or "confirm or override"). The full 10-section structured brief is reserved for genuinely ambiguous, multi-screen, or stakeholder-heavy tasks. Don't pad a clear brief into a long one to look thorough; equally, don't skip the pause to look efficient. + +If the harness has native image generation (Codex), a compact shape's "confirm or override" advances to **Step 3 and the codex.md flow**, not to Step 4. Phrase the closing line accordingly: "Confirm or override; once we lock direction, I'll run a couple of palette and reference questions before generating any mocks." This stops the model from reading shape confirmation as code-green. + +## Step 2: Load References + +Based on the design brief's "Recommended References" section, consult the relevant impeccable reference files. At minimum, always consult: + +- [spatial-design.md](spatial-design.md) for layout and spacing +- [typography.md](typography.md) for type hierarchy + +Then add references based on the brief's needs: +- Complex interactions or forms? Consult [interaction-design.md](interaction-design.md) +- Animation or transitions? Consult [motion-design.md](motion-design.md) +- Color-heavy or themed? Consult [color-and-contrast.md](color-and-contrast.md) +- Responsive requirements? Consult [responsive-design.md](responsive-design.md) +- Heavy on copy, labels, or errors? Consult [ux-writing.md](ux-writing.md) + +## Step 3: Visual Direction & Assets (Harness-Gated) + +If the harness has **native image generation** (currently Codex via `image_gen`), this step is mandatory. **Stop and load [codex.md](codex.md)**. It covers palette generation, mock exploration, the approval loop, mock-fidelity inventory, and asset slicing via the `impeccable_asset_producer` subagent. Follow Steps A-F in that file, then return here for Step 4. + +If the harness lacks native image generation, **state in one line that the visual-direction-by-generation step is being skipped because the harness lacks native image generation, then proceed**. The one-line announcement is required; it forces a conscious decision instead of letting the step quietly evaporate. The brief is your only visual reference. Implement directly from it, treating any named anchor references and the brief's "Design Direction" as the contract. + +Whether you generated mocks or not: don't replace required imagery with generic cards, bullets, emoji, fake metrics, decorative CSS panels, or filler copy. Image-led briefs (restaurants, hotels, magazines, photography, hobbyist communities, food, travel, fashion, product) need real or sourced imagery in the build, not CSS scenery. + +## Step 4: Build to Production Quality + +**Precondition.** If Step 3 routed you to codex.md (native image generation available), Steps A through D in that file must be complete before any code: questions answered, palette confirmed, mocks generated, one direction approved or delegated. **Do not mention implementation, file paths, or patch plans until that's done.** A confirmed shape brief is not enough; the model that compressed those gates is the model that already failed this flow. + +Implement the feature following the design brief. Build in passes so structure, visual system, states, motion/media, and responsive behavior each get deliberate attention. The list below is the definition of done, not inspiration. + +### Production bar + +- **Real content.** No placeholder copy, placeholder images, dead links, fake controls, or unused scaffold at presentation time. +- **Preserve the approved mock's major ingredients.** Missing hero objects, world/product imagery, section structure, CTA/nav treatment, or distinctive motifs are blocking defects unless the user accepted the change. +- **Semantic first.** Real headings, landmarks, labels, form associations, button/link semantics, accessible names, state announcements where needed. +- **Deliberate spacing and alignment.** No default gaps, arbitrary margins, unbalanced whitespace, or accidental optical misalignment. +- **Intentional typography.** Chosen loading strategy, clear hierarchy, readable measure, stable line breaks, no overflow at any width. +- **Realistic state coverage.** Default, hover, focus-visible, active, disabled, loading, error, success, empty, overflow, long/short text, first-run. +- **Finished interaction quality.** Keyboard paths, touch targets, feedback timing, scroll behavior, state transitions, no hover-only functionality. +- **Coherent icon set.** Use the project's established set; otherwise pick one library or use accessible text. Don't mix. +- **Respect the build pipeline.** Edit source files and run the project's build (`npm run build` or equivalent). Don't write to `build/` / `dist/` / `.next/` with `cat`, heredoc, or Bash redirects; that skips asset hashing, image optimization, code splitting, and CSS extraction, and produces output the dev server won't serve. +- **Verify image URLs before referencing them.** Use image-search MCP or web-fetch when available; guessed photo IDs ship as broken-image placeholders. Without verification, prefer fewer images you're confident about. +- **Optimized imagery and media.** Correct dimensions, useful alt text, lazy loading below the fold, modern formats when practical, responsive `srcset`/`picture` for raster, no project-referenced asset left outside the workspace. +- **Premium motion.** Use atmospheric blur, filter, mask, shadow, reveal when they improve the experience. Avoid casual layout-property animation, bound expensive effects, verify smoothness in-browser, respect reduced motion, and avoid choreography that blocks task completion. +- **Maintainable.** Reusable local patterns, clear component boundaries, project conventions. No rasterized UI text or one-off hacks when a local pattern exists. +- **Technically clean.** Production build passes, no console errors, no avoidable layout shift, no needless dependencies, no broken asset paths. +- **Ask when uncertain.** If a discovery materially changes the brief or approved direction, stop and ask. Don't guess. + +## Step 5: Iterate Visually + +Look at what you built like a designer would. Your eyes are whatever the harness gives you: a connected browser, a screenshotting tool, Playwright, or asking the user. Use them for responsive testing (mobile, tablet, desktop minimum) and general visual validation. + +If your tool returns a file path, read the PNG back into the conversation. A screenshot you didn't read doesn't count. + +For long-form brand surfaces, inspect major sections individually. Thumbnails hide spacing, clipping, and cascade defects. + +After the first pass, write an honest critique against the brief, the approved mock's major ingredients (hero silhouette, motifs, imagery, nav/CTA, density), and impeccable's DON'Ts. Patch material defects and re-inspect. **Don't invent defects to demonstrate iteration.** A confident "first pass clean, shipping" beats a fake fix. + +Actively check: responsive behavior (composes, not shrinks), every state (empty / error / loading / edge), craft details (spacing, alignment, hierarchy, contrast, motion timing, focus), performance basics. The exit bar: defensible in a high-end studio review. + +Detector or QA output is defect evidence only; never proof the work is finished. + +## Step 6: Present + +Present the result to the user: +- Show the feature in its primary state +- Summarize the browser/viewports checked and the most important fixes made after inspection +- Walk through the key states (empty, error, responsive) +- Explain design decisions that connect back to the design brief and, when used, the chosen north-star mock. Include any accepted deviations from the mock; do not hide unimplemented mock ingredients. +- Note any remaining limitations or follow-up risks honestly +- Ask: "What's working? What isn't?" diff --git a/.agents/skills/impeccable/reference/critique.md b/.agents/skills/impeccable/reference/critique.md new file mode 100644 index 00000000..4e84fcb5 --- /dev/null +++ b/.agents/skills/impeccable/reference/critique.md @@ -0,0 +1,259 @@ +### Purpose + +Resolve one stable target, run two independent assessments, synthesize a design critique, persist a snapshot, and ask the user what to improve next. The chat response is the primary deliverable; the snapshot is an archive/backlog for future commands. + +### Hard Invariants + +- Assessment A (design review) and Assessment B (detector/browser evidence) are both required. +- Assessment A must finish before detector findings enter the parent synthesis context. Detector output is deterministic, but it still anchors judgment. +- If sub-agents are unavailable, fall back sequentially: finish and record Assessment A first, then run Assessment B, then synthesize. +- A skipped detector is a failed critique run unless `detect.mjs` is missing or crashes after a real attempt. +- Viewable targets require browser inspection when available. +- Any local server started only for critique visualization must run in the background, have a recorded stop method, and be stopped before final reporting unless the user asks to keep it. +- Do not claim a user-visible overlay exists unless script injection succeeded and the detector ran in the page. + +### Setup + +1. **Resolve the target** to a concrete file path or URL. Prefer a source path over a dev-server URL when both identify the same surface; ports drift, paths do not. + - "the homepage" -> `site/pages/index.astro` or `index.html` + - "the settings modal" -> the primary component file + - "this page" -> the current URL or source file +2. **Compute the slug**: + ```bash + node .agents/skills/impeccable/scripts/critique-storage.mjs slug "" + ``` + Keep it. If the command exits non-zero, skip persistence and trend for this run, but continue the critique. +3. **Read `.impeccable/critique/ignore.md`** if it exists. Drop matching findings silently; it is the only prior-run input critique consumes. + +### Assessment Orchestration + +Delegate Assessment A and Assessment B to separate sub-agents when possible. They must not see each other's output. Do not show findings to the user until synthesis. + +Codex sub-agent gate: +- If `spawn_agent` is exposed and the user explicitly allowed sub-agents, delegation, or parallel agent work, spawn A and B immediately. +- If `spawn_agent` is exposed but the user did not explicitly allow sub-agents, ask exactly once: "Impeccable critique is designed to run two independent sub-agents for an unanchored assessment. May I use sub-agents for this critique?" Then stop until the user answers. +- If allowed, spawn A and B. If declined, run sequentially and report `Assessment independence: degraded (sub-agents declined by user)`. +- If `spawn_agent` is not exposed, do not ask; run sequentially and report `Assessment independence: degraded (spawn_agent unavailable in this session)`. +- If spawning fails after permission, run sequentially and report `Assessment independence: degraded (sub-agent spawn failed: )`. +Prefer `fork_context: false` with self-contained prompts containing cwd, target, live URL, references, product context, and output contract. If using `fork_context: true`, omit `agent_type`, `model`, and `reasoning_effort`. + +If browser automation is available, each assessment creates its own new tab. Never reuse an existing tab, even if it is already at the right URL. + +### Assessment A: Design Review + +Read relevant source files and visually inspect the live page when browser automation is available. Think like a design director. + +Evaluate: +- **AI slop**: Would someone believe "AI made this" immediately? Check all DON'T guidance from the parent Impeccable skill. +- **Holistic design**: hierarchy, IA, emotional fit, discoverability, composition, typography, color, accessibility, states, copy, and edge cases. +- **Cognitive load**: consult [cognitive-load](cognitive-load.md); report checklist failures and decision points with >4 visible options. +- **Emotional journey**: peak-end rule, emotional valleys, reassurance at high-stakes moments. +- **Nielsen heuristics**: consult [heuristics-scoring](heuristics-scoring.md); score all 10 heuristics 0-4. + +Return: AI slop verdict, heuristic scores, cognitive load, emotional journey, 2-3 strengths, 3-5 priority issues, persona red flags, minor observations, and provocative questions. + +### Assessment B: Detector + Browser Evidence + +Run the bundled detector and browser visualization evidence. Assessment B is mandatory and must remain isolated from Assessment A until both are complete. + +CLI scan: +```bash +node .agents/skills/impeccable/scripts/detect.mjs --json [--fast] [target] +``` + +- Pass markup files/directories as `[target]`; do not pass CSS-only files. +- For URLs, skip CLI scan and use browser visualization. +- For 200+ scannable files, use `--fast`; for 500+, narrow scope or ask. +- Exit code 0 = clean; 2 = findings. +- If the detector entrypoint is missing or fails to load, report deterministic scan unavailable and continue with browser/manual review. + +Browser visualization is required for a viewable target when browser automation is available. Use a localhost dev/static URL for local files; avoid `file://` unless the available browser explicitly supports this workflow. Overlay flow: + +1. Create a fresh tab and navigate. +2. Preflight mutable injection by setting `document.title` and appending a ` + * Re-scan: window.impeccableScan() + */ +(function () { +if (typeof window === 'undefined') return; +// --- cli/engine/shared/constants.mjs --- +// ─── Section 1: Constants ─────────────────────────────────────────────────── + +const SAFE_TAGS = new Set([ + 'blockquote', 'nav', 'a', 'input', 'textarea', 'select', + 'pre', 'code', 'span', 'th', 'td', 'tr', 'li', 'label', + 'button', 'hr', 'html', 'head', 'body', 'script', 'style', + 'link', 'meta', 'title', 'br', 'img', 'svg', 'path', 'circle', + 'rect', 'line', 'polyline', 'polygon', 'g', 'defs', 'use', +]); + +// Per-check safe-tags override for the border (side-tab / border-accent) +// rule. We intentionally re-allow