whale-igniter 1.1.0

package/dist/selene/promptBuilder.js

@@ -0,0 +1,229 @@
+/**
+ * Selene prompt composer.
+ *
+ * Every prompt has the same shape:
+ *
+ *   1. Identity — who Whale is, what this file is for
+ *   2. Project context — foundations, conventions, active decisions and
+ *      refinements (a compressed view, not the full wiki)
+ *   3. Task — what the LLM should do
+ *   4. Input — the code/data the task operates on
+ *   5. Output format — strict, so we can parse the response back
+ *
+ * The fifth section is the one most people skip. Without it, the LLM
+ * returns markdown prose that can't be machine-parsed, so the round
+ * trip into `whale selene apply` becomes manual. We're aggressive about
+ * specifying the output shape — usually a fenced JSON block with a
+ * known schema.
+ */
+// ---------------------------------------------------------------------------
+// Shared sections
+// ---------------------------------------------------------------------------
+function renderIdentity() {
+    return [
+        "You are helping maintain operational context for a project managed by Whale Igniter.",
+        "Whale stores design-system foundations, decisions, conventions, and a component",
+        "catalog in machine-readable form so AI agents understand the project without",
+        "re-explanation. Your output will be consumed by a CLI parser, so follow the",
+        "Output Format section exactly."
+    ].join("\n");
+}
+function renderProjectContext(ctx) {
+    const lines = ["## Project context"];
+    const c = ctx.config;
+    lines.push("");
+    lines.push("**Project**");
+    lines.push(`- Name: ${c.projectName ?? "(unset)"}`);
+    lines.push(`- Type: ${c.projectType ?? "unspecified"}`);
+    lines.push(`- Stack: ${c.stack ?? "css"}`);
+    lines.push("");
+    lines.push("**Foundations**");
+    lines.push(`- Grid: ${c.foundations?.grid ?? 8}px (all spacing must be a multiple)`);
+    lines.push(`- Control radius: ${c.foundations?.radius?.control ?? 4}px (buttons, inputs)`);
+    lines.push(`- Container radius: ${c.foundations?.radius?.container ?? 8}px (cards, modals)`);
+    // Active decisions — show titles only to keep tokens down. Full text
+    // is available in intelligence/decisions.json if the model needs it.
+    const active = ctx.decisions.filter((d) => d.status === "active");
+    if (active.length > 0) {
+        lines.push("");
+        lines.push("**Active decisions** (most recent first)");
+        const recent = [...active].sort((a, b) => b.timestamp.localeCompare(a.timestamp)).slice(0, 8);
+        for (const d of recent) {
+            lines.push(`- [${d.category}] ${d.title}`);
+        }
+        if (active.length > recent.length) {
+            lines.push(`- … and ${active.length - recent.length} more in intelligence/decisions.json`);
+        }
+    }
+    if (ctx.refinements.length > 0) {
+        lines.push("");
+        lines.push("**Approved exceptions (refinements)**");
+        const recent = [...ctx.refinements].sort((a, b) => b.timestamp.localeCompare(a.timestamp)).slice(0, 6);
+        for (const r of recent) {
+            const scope = r.scope?.issueType ? ` _(${r.scope.issueType})_` : "";
+            lines.push(`- ${r.note}${scope}`);
+        }
+    }
+    if (ctx.components.length > 0) {
+        lines.push("");
+        lines.push("**Existing components in catalog**");
+        const names = ctx.components.map((c) => c.name).sort().slice(0, 30);
+        lines.push(names.join(", ") + (ctx.components.length > 30 ? `, … (${ctx.components.length} total)` : ""));
+    }
+    lines.push("");
+    lines.push("**Universal rules**");
+    lines.push(`- Spacing is a multiple of ${c.foundations?.grid ?? 8}px.`);
+    lines.push("- Use semantic tokens over raw color values.");
+    lines.push("- Every interactive element needs a visible :focus-visible state.");
+    return lines.join("\n");
+}
+function fence(label, content) {
+    return "```" + label + "\n" + content + "\n```";
+}
+export function buildDescribePrompt(ctx, input) {
+    const sections = [];
+    sections.push("# Whale Selene — describe component");
+    sections.push("");
+    sections.push(renderIdentity());
+    sections.push("");
+    sections.push(renderProjectContext(ctx));
+    sections.push("");
+    sections.push("## Task");
+    sections.push("");
+    sections.push(`Write a catalog entry for the component named \`${input.componentName}\` (file: \`${input.filePath}\`).`);
+    sections.push("");
+    sections.push("Read the source below and produce:");
+    sections.push("- A one-sentence `description` (≤ 140 chars) suitable for a component catalog.");
+    sections.push("- A `category` (one of: form, navigation, feedback, surface, layout, data, overlay) — pick the best fit.");
+    sections.push("- `variants` — the visual variants accepted as props (e.g. primary, secondary). Empty array if none.");
+    sections.push("- `states` — interactive states styled in the component (e.g. hover, focus, disabled). Empty if none.");
+    sections.push("- `tokens` — design tokens / Tailwind classes the component depends on (limit to the 8 most central).");
+    sections.push("");
+    if (input.existingEntry) {
+        sections.push("**Existing catalog entry for this component (refine, don't restate):**");
+        sections.push(fence("json", JSON.stringify(input.existingEntry, null, 2)));
+        sections.push("");
+    }
+    sections.push("## Input — source");
+    sections.push("");
+    sections.push(fence(extLang(input.filePath), input.fileContents));
+    sections.push("");
+    sections.push("## Output format");
+    sections.push("");
+    sections.push("Return a single fenced JSON block with the exact shape below. Nothing before or after — no preamble, no explanation.");
+    sections.push("");
+    sections.push(fence("json", JSON.stringify({
+        name: input.componentName,
+        description: "string ≤ 140 chars",
+        category: "form | navigation | feedback | surface | layout | data | overlay",
+        variants: ["string"],
+        states: ["string"],
+        tokens: ["string"]
+    }, null, 2)));
+    return sections.join("\n");
+}
+export function buildAuditPrompt(ctx, input) {
+    const sections = [];
+    sections.push("# Whale Selene — audit file");
+    sections.push("");
+    sections.push(renderIdentity());
+    sections.push("");
+    sections.push(renderProjectContext(ctx));
+    sections.push("");
+    sections.push("## Task");
+    sections.push("");
+    sections.push(`Audit the file below against this project's foundations, conventions, and active decisions.`);
+    sections.push("");
+    sections.push("For each issue you find, produce one entry. Be specific — quote the exact line if you can.");
+    sections.push("Do NOT flag issues that are already covered by an approved refinement listed above.");
+    sections.push("");
+    sections.push("## Input — file");
+    sections.push("");
+    sections.push(`\`${input.filePath}\``);
+    sections.push("");
+    sections.push(fence(extLang(input.filePath), input.fileContents));
+    sections.push("");
+    sections.push("## Output format");
+    sections.push("");
+    sections.push("Return a single fenced JSON block. Each issue has: `severity` (critical|warning|info), `rule` (one of: grid, radius, color, focus, naming, accessibility, decision, other), `line` (number, optional), `message` (one sentence), `suggestion` (concrete fix).");
+    sections.push("");
+    sections.push(fence("json", JSON.stringify({
+        file: input.filePath,
+        issues: [
+            { severity: "warning", rule: "grid", line: 12, message: "...", suggestion: "..." }
+        ]
+    }, null, 2)));
+    sections.push("");
+    sections.push("If the file is fully compliant, return `{ \"file\": \"...\", \"issues\": [] }`.");
+    return sections.join("\n");
+}
+export function buildSuggestPrompt(ctx, input = {}) {
+    const sections = [];
+    sections.push("# Whale Selene — suggest patterns");
+    sections.push("");
+    sections.push(renderIdentity());
+    sections.push("");
+    sections.push(renderProjectContext(ctx));
+    sections.push("");
+    sections.push("## Task");
+    sections.push("");
+    sections.push("Looking at the project context above, suggest up to five patterns, conventions, or decisions worth recording.");
+    sections.push("");
+    sections.push("Good suggestions:");
+    sections.push("- Consolidate repeated refinements into a foundation change.");
+    sections.push("- Promote an implicit convention into a recorded decision.");
+    sections.push("- Flag a gap between what the codebase does and what's documented.");
+    sections.push("");
+    sections.push("Bad suggestions:");
+    sections.push("- Generic best practices not tied to evidence above.");
+    sections.push("- Restatements of rules already listed.");
+    sections.push("");
+    if (input.focus && input.focus !== "all") {
+        sections.push(`**Focus area:** ${input.focus}`);
+        sections.push("");
+    }
+    sections.push("## Output format");
+    sections.push("");
+    sections.push("Return a single fenced JSON block. Each suggestion has: `title` (≤ 80 chars), `kind` (decision|refinement|foundation|cleanup), `category` (architecture|design-system|product|tooling|convention), `rationale` (1-2 sentences citing evidence), `proposed_text` (the actual decision/refinement text to record).");
+    sections.push("");
+    sections.push(fence("json", JSON.stringify({
+        suggestions: [
+            {
+                title: "string",
+                kind: "decision",
+                category: "design-system",
+                rationale: "string",
+                proposed_text: "string"
+            }
+        ]
+    }, null, 2)));
+    return sections.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function extLang(filePath) {
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    switch (ext) {
+        case "tsx":
+        case "ts":
+            return "typescript";
+        case "jsx":
+        case "js":
+            return "javascript";
+        case "css":
+            return "css";
+        case "scss":
+            return "scss";
+        case "vue":
+            return "vue";
+        case "svelte":
+            return "svelte";
+        case "json":
+            return "json";
+        case "md":
+            return "markdown";
+        default:
+            return "";
+    }
+}

package/dist/selene/providers.js

@@ -0,0 +1,67 @@
+/**
+ * Provider detection for Selene.
+ *
+ * Lookup order:
+ *   1. Explicit `--provider <name>` (handled by the command layer).
+ *   2. `selene.provider` in whale.config.json.
+ *   3. First key found in env: ANTHROPIC_API_KEY, then OPENAI_API_KEY.
+ *
+ * If nothing matches, we return `null` — the caller should fall back
+ * to prompt mode. We never throw for "no key" because that's the
+ * normal v0.10 path; absence of credentials is supported on purpose.
+ */
+const DEFAULT_MODELS = {
+    // Conservative defaults — newest "stable" public models as of early 2026.
+    // The user can override via whale.config.json → selene.model.
+    anthropic: "claude-sonnet-4-6",
+    openai: "gpt-4.1-mini"
+};
+const ENV_KEYS = {
+    anthropic: "ANTHROPIC_API_KEY",
+    openai: "OPENAI_API_KEY"
+};
+export function resolveProvider(config, options = {}) {
+    // Build the ordered list of providers to try.
+    const order = [];
+    if (options.force)
+        order.push(options.force);
+    if (config.selene?.provider && !order.includes(config.selene.provider)) {
+        order.push(config.selene.provider);
+    }
+    // Fill remaining providers as fallback so that, when force isn't set,
+    // we'll happily use whatever key the user has.
+    for (const p of ["anthropic", "openai"]) {
+        if (!order.includes(p))
+            order.push(p);
+    }
+    for (const provider of order) {
+        const envName = ENV_KEYS[provider];
+        const fromEnv = process.env[envName];
+        if (fromEnv && fromEnv.trim().length > 0) {
+            return {
+                provider,
+                apiKey: fromEnv.trim(),
+                model: options.modelOverride ?? config.selene?.model ?? DEFAULT_MODELS[provider],
+                source: "env"
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Friendly description of what's available — useful for `whale selene status`
+ * and for error messages when the user explicitly forced a provider.
+ */
+export function describeProviderState() {
+    return ["anthropic", "openai"].map((provider) => {
+        const envName = ENV_KEYS[provider];
+        return {
+            provider,
+            envName,
+            available: !!process.env[envName] && process.env[envName].trim().length > 0
+        };
+    });
+}
+export function defaultModelFor(provider) {
+    return DEFAULT_MODELS[provider];
+}

package/dist/selene/responseParser.js

@@ -0,0 +1,149 @@
+/**
+ * Parse LLM responses pasted back by the user.
+ *
+ * Real-world responses are messy: a preamble paragraph, then a fenced
+ * code block, then more prose. Sometimes multiple JSON blocks. We
+ * extract the first one that parses AND matches the expected shape,
+ * silently skipping the rest.
+ *
+ * If nothing parses, we return a structured error so the command can
+ * tell the user what went wrong (e.g. "I found a JSON block but it
+ * didn't match the expected schema").
+ */
+/**
+ * Extract every fenced code block from a markdown-ish string. We accept
+ * ```json, ```JSON, ```, and treat them all the same — we'll parse and
+ * see. The regex deliberately uses [\s\S] not . so that newlines match.
+ */
+function extractFencedBlocks(text) {
+    const out = [];
+    const re = /```(?:[a-zA-Z]+)?\s*\n([\s\S]*?)```/g;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        out.push(m[1]);
+    }
+    return out;
+}
+/**
+ * Some users paste raw JSON without fences. Try to recognize a JSON
+ * payload by hunting for the outermost balanced brace pair.
+ */
+function extractBareJsonPayload(text) {
+    const start = text.indexOf("{");
+    if (start === -1)
+        return null;
+    let depth = 0;
+    for (let i = start; i < text.length; i += 1) {
+        const ch = text[i];
+        if (ch === "{")
+            depth += 1;
+        else if (ch === "}") {
+            depth -= 1;
+            if (depth === 0)
+                return text.slice(start, i + 1);
+        }
+    }
+    return null;
+}
+function tryParse(payload) {
+    try {
+        return JSON.parse(payload);
+    }
+    catch {
+        return null;
+    }
+}
+export function parseJsonResponse(text, validate) {
+    const candidates = [...extractFencedBlocks(text)];
+    const bare = extractBareJsonPayload(text);
+    if (bare && !candidates.includes(bare))
+        candidates.push(bare);
+    if (candidates.length === 0) {
+        return { ok: false, reason: "No JSON found in the response." };
+    }
+    let lastSyntax = null;
+    let lastShape = null;
+    for (const c of candidates) {
+        const parsed = tryParse(c);
+        if (parsed === null) {
+            lastSyntax = "Found a code block but couldn't parse it as JSON.";
+            continue;
+        }
+        if (validate(parsed)) {
+            return { ok: true, value: parsed };
+        }
+        lastShape = "Parsed JSON but its shape didn't match the expected schema.";
+    }
+    return { ok: false, reason: lastShape ?? lastSyntax ?? "No usable JSON found." };
+}
+export function isDescribeResponse(v) {
+    if (!v || typeof v !== "object")
+        return false;
+    const o = v;
+    if (typeof o.name !== "string" || o.name.length === 0)
+        return false;
+    if (typeof o.description !== "string" || o.description.length === 0)
+        return false;
+    if (o.category !== undefined && typeof o.category !== "string")
+        return false;
+    if (o.variants !== undefined && !isStringArray(o.variants))
+        return false;
+    if (o.states !== undefined && !isStringArray(o.states))
+        return false;
+    if (o.tokens !== undefined && !isStringArray(o.tokens))
+        return false;
+    return true;
+}
+export function isAuditResponse(v) {
+    if (!v || typeof v !== "object")
+        return false;
+    const o = v;
+    if (typeof o.file !== "string")
+        return false;
+    if (!Array.isArray(o.issues))
+        return false;
+    for (const i of o.issues) {
+        if (!i || typeof i !== "object")
+            return false;
+        const iss = i;
+        if (iss.severity !== "critical" && iss.severity !== "warning" && iss.severity !== "info")
+            return false;
+        if (typeof iss.rule !== "string")
+            return false;
+        if (typeof iss.message !== "string")
+            return false;
+        if (iss.line !== undefined && typeof iss.line !== "number")
+            return false;
+        if (iss.suggestion !== undefined && typeof iss.suggestion !== "string")
+            return false;
+    }
+    return true;
+}
+export function isSuggestResponse(v) {
+    if (!v || typeof v !== "object")
+        return false;
+    const o = v;
+    if (!Array.isArray(o.suggestions))
+        return false;
+    const validKinds = new Set(["decision", "refinement", "foundation", "cleanup"]);
+    const validCats = new Set(["architecture", "design-system", "product", "tooling", "convention"]);
+    for (const s of o.suggestions) {
+        if (!s || typeof s !== "object")
+            return false;
+        const sg = s;
+        if (typeof sg.title !== "string" || sg.title.length === 0)
+            return false;
+        if (typeof sg.kind !== "string" || !validKinds.has(sg.kind))
+            return false;
+        if (typeof sg.category !== "string" || !validCats.has(sg.category))
+            return false;
+        if (typeof sg.rationale !== "string")
+            return false;
+        if (typeof sg.proposed_text !== "string" || sg.proposed_text.length === 0)
+            return false;
+    }
+    return true;
+}
+function isStringArray(v) {
+    return Array.isArray(v) && v.every((x) => typeof x === "string");
+}

package/dist/ui/atoms.js

@@ -0,0 +1,30 @@
+/**
+ * Atoms — thin wrappers over theme tokens. Commands import these
+ * instead of chalk directly.
+ *
+ * Two reasons:
+ *   1. Decouples commands from chalk so the theme can change later
+ *      without grep-and-replace across the codebase.
+ *   2. Lets us inject behaviour later (e.g. strip colors when
+ *      NO_COLOR is set, or when piping). The atoms are the choke point.
+ */
+import { theme } from "./theme.js";
+export const accent = (text) => theme().identity.accent(text);
+export const emphasis = (text) => theme().identity.emphasis(text);
+export const success = (text) => theme().semantic.success(text);
+export const warning = (text) => theme().semantic.warning(text);
+export const danger = (text) => theme().semantic.danger(text);
+export const info = (text) => theme().semantic.info(text);
+export const muted = (text) => theme().semantic.muted(text);
+export const code = (text) => theme().semantic.code(text);
+export const path = (text) => theme().semantic.path(text);
+export const heading = (text) => theme().semantic.heading(text);
+export const subheading = (text) => theme().semantic.subheading(text);
+/**
+ * Compose styles by wrapping the inner first.
+ *
+ * Example: `compose(accent, emphasis)("Whale")` → bold cyan "Whale".
+ */
+export function compose(...styles) {
+    return (text) => styles.reduceRight((acc, fn) => fn(acc), text);
+}

package/dist/ui/blocks.js

@@ -0,0 +1,208 @@
+/**
+ * Blocks — composable output primitives.
+ *
+ * Each function returns a *string*, never side-effects. The caller
+ * decides where to write it (typically `process.stdout`, but tests
+ * and the MCP server need to capture the text instead).
+ *
+ * Output style guide:
+ *   - One blank line before and after every block-level element.
+ *   - Two-space indent for nested content.
+ *   - Symbols carry semantic weight; color reinforces them.
+ *   - Headings are bold, not coloured (unless they ARE the brand mark).
+ */
+import { theme } from "./theme.js";
+import { glyph } from "./symbols.js";
+import { accent, emphasis, muted, success, warning, danger, info, path as pathStyle, code as codeStyle, subheading } from "./atoms.js";
+const NL = "\n";
+const INDENT = "  ";
+// ---------------------------------------------------------------------------
+// Page-level
+// ---------------------------------------------------------------------------
+/**
+ * The opening line of a command. Brand-coloured diamond + title in bold.
+ *
+ *   ◆ Whale Igniter — ignite (opinionated)
+ *
+ * The optional `subtitle` is rendered dimmer on the same line.
+ */
+export function header(title, subtitle) {
+    const left = `${glyph.diamond} ${emphasis(title)}`;
+    if (!subtitle)
+        return left;
+    return `${left} ${muted("— " + subtitle)}`;
+}
+/**
+ * Standalone section label. Use to separate logical chunks within a
+ * single command's output.
+ *
+ *   Foundations
+ */
+export function section(label) {
+    return emphasis(label);
+}
+/**
+ * Sub-section — a small label that introduces a list or table.
+ *
+ *   Active packs:
+ */
+export function subsection(label) {
+    return subheading(label + ":");
+}
+/**
+ * Visual rule across the terminal width. Used between major blocks
+ * when whitespace alone isn't enough. We don't query terminal width
+ * — 72 columns is a sane default that matches most diff viewers.
+ */
+export function rule(width = 72) {
+    return muted(theme().symbols.rule.repeat(width));
+}
+// ---------------------------------------------------------------------------
+// Inline elements
+// ---------------------------------------------------------------------------
+/**
+ * Key/value line:  `key: value`
+ *
+ * The key is dim, the value uses the caller's intent.
+ * If `keyWidth` is set, the key is padded to that width *before* the colon,
+ * so columns align.
+ *
+ *   grid:    8px  high
+ *   radii:   ...
+ */
+export function kv(key, value, opts = {}) {
+    const keyText = key + ":";
+    const padded = opts.keyWidth ? keyText.padEnd(opts.keyWidth + 1) : keyText;
+    return `${muted(padded)} ${value}`;
+}
+/**
+ * Indented bullet with the project's bullet glyph.
+ *
+ *   • text here
+ */
+export function bullet(text, level = 0) {
+    return INDENT.repeat(level + 1) + glyph.bullet + " " + text;
+}
+/**
+ * Indented "dot" bullet — for nested or tertiary lists.
+ *
+ *   · text here
+ */
+export function dot(text, level = 0) {
+    return INDENT.repeat(level + 1) + glyph.dot + " " + muted(text);
+}
+/**
+ * A "next" hint — directs the user to a follow-up command.
+ *
+ *   → whale adopt review
+ */
+export function next(action) {
+    return `${glyph.arrow} ${action}`;
+}
+// ---------------------------------------------------------------------------
+// Status lines (single-line statements of outcome)
+// ---------------------------------------------------------------------------
+export function ok(text) {
+    return `${glyph.check} ${text}`;
+}
+export function fail(text) {
+    return `${glyph.cross} ${danger(text)}`;
+}
+export function warn(text) {
+    return `${glyph.warn} ${warning(text)}`;
+}
+export function note(text) {
+    return `${glyph.info} ${muted(text)}`;
+}
+// ---------------------------------------------------------------------------
+// Badges — short coloured tags for inline use
+// ---------------------------------------------------------------------------
+const BADGE_PAD = " ";
+function badge(label, style) {
+    return style(BADGE_PAD + label + BADGE_PAD);
+}
+export const badges = {
+    success: (text) => badge(text, success),
+    warning: (text) => badge(text, warning),
+    danger: (text) => badge(text, danger),
+    info: (text) => badge(text, info),
+    muted: (text) => badge(text, muted)
+};
+// ---------------------------------------------------------------------------
+// Containers — multi-line layouts
+// ---------------------------------------------------------------------------
+/**
+ * Indent a block of text. Common need: rendering a multi-line paragraph
+ * inside a section without manually prefixing each line.
+ */
+export function indent(text, level = 1) {
+    const prefix = INDENT.repeat(level);
+    return text
+        .split(NL)
+        .map((line) => (line.length > 0 ? prefix + line : line))
+        .join(NL);
+}
+/**
+ * A titled panel with content underneath. Top line is the section name,
+ * content is indented, ends with a blank line.
+ *
+ *   Foundations
+ *     grid:           8px
+ *     control radius: 2px
+ *     container:      4px
+ *
+ * Pass `lines` already-formatted (kv, bullet, etc.) — panel just stitches.
+ */
+export function panel(title, lines) {
+    return section(title) + NL + indent(lines.join(NL));
+}
+/**
+ * A summary footer — typically used at the end of a long command to
+ * recap counts or status. Renders as a single line with separators.
+ *
+ *   accepted 5  ·  rejected 0  ·  skipped 1
+ */
+export function summary(parts) {
+    const rendered = parts.map((p) => {
+        const valueStr = String(p.value);
+        const styled = p.tone === "ok" ? success(valueStr)
+            : p.tone === "warn" ? warning(valueStr)
+                : p.tone === "danger" ? danger(valueStr)
+                    : p.tone === "muted" ? muted(valueStr)
+                        : valueStr;
+        return `${muted(p.label)} ${styled}`;
+    });
+    return rendered.join(muted("  ·  "));
+}
+// ---------------------------------------------------------------------------
+// Re-exports for ergonomics — commands often `import { ui } from "..."`
+// ---------------------------------------------------------------------------
+export const ui = {
+    header,
+    section,
+    subsection,
+    rule,
+    kv,
+    bullet,
+    dot,
+    next,
+    ok,
+    fail,
+    warn,
+    note,
+    badges,
+    indent,
+    panel,
+    summary,
+    glyph,
+    // atoms passthrough for cases where a single coloured word is enough
+    accent,
+    emphasis,
+    muted,
+    success,
+    warning,
+    danger,
+    info,
+    code: codeStyle,
+    path: pathStyle
+};