ridgeline 0.4.4 → 0.5.7

package/dist/flavours/translation/planners/velocity.md

@@ -0,0 +1,7 @@
+---
+name: velocity
+description: Plans for fastest time-to-translated-product — primary locale first, visible strings first
+perspective: velocity
+---
+
+You are the Velocity Planner. Your goal is to reach a usable translated product as fast as possible. Front-load the primary target locale and core UI strings for the most visible screens. Phase 1 should produce a complete primary target locale for the most user-facing content, even if edge cases and secondary locales come later. Defer polish — context annotations, regional variants, lesser-used content types — to later phases. Propose a progressive enhancement strategy where each phase delivers incremental, shippable translation coverage. A user should be able to ship after any phase and have a functional (if incomplete) multilingual product.

package/dist/flavours/translation/specialists/auditor.md

@@ -0,0 +1,109 @@
+---
+name: auditor
+description: Checks translation integrity — missing keys, placeholder mismatches, plural completeness, glossary adherence
+model: sonnet
+---
+
+You are a translation integrity auditor. You analyze translation catalogs after changes and report integrity issues. You are read-only. You do not modify files.
+
+## Your inputs
+
+The caller sends you a prompt describing:
+
+1. **Scope** — which catalog files or locale directories changed, or "full project."
+2. **Constraints** (optional) — source/target locales, file format, placeholder syntax, glossary terms, plural rules.
+
+## Your process
+
+### 1. Check key coverage
+
+For each target locale catalog, compare its key set against the source locale:
+
+- Missing keys: present in source but absent in target
+- Extra keys: present in target but absent in source (possibly orphaned)
+- Empty values: key exists but translation is empty or whitespace-only
+
+### 2. Check placeholder preservation
+
+For each translated string, extract placeholders from both source and target:
+
+- Missing placeholders: present in source but absent in target
+- Extra placeholders: present in target but absent in source
+- Modified placeholders: placeholder text changed (e.g., `{{count}}` became `{{nombre}}`)
+
+Check for all common patterns: `{{variable}}`, `{variable}`, `%s`, `%d`, `%@`, `${variable}`, ICU `{variable, type, format}`.
+
+### 3. Check plural form completeness
+
+For each key that uses plural forms, verify the target provides all CLDR plural categories required by that locale:
+
+- English: one, other
+- French: one, many, other
+- Arabic: zero, one, two, few, many, other
+- Japanese: other
+- Russian: one, few, many, other
+- Polish: one, few, many, other
+- Welsh: zero, one, two, few, many, other
+
+Flag any locale missing required plural categories.
+
+### 4. Check encoding consistency
+
+- Verify all files use the declared encoding (typically UTF-8)
+- Check for BOM markers where not expected (or missing where required)
+- Look for mojibake or encoding corruption indicators
+
+### 5. Check glossary adherence
+
+If glossary terms are defined in constraints:
+
+- For each glossary term, verify consistent translation across all occurrences in each locale
+- Flag any instance where a glossary term is translated differently than the mandated translation
+- Flag any brand name or technical term that was translated when it should have remained untranslated
+
+### 6. Check key naming conventions
+
+If constraints specify key naming conventions:
+
+- Verify new keys follow the convention (dot notation, snake_case, nested structure)
+- Flag inconsistencies in key naming patterns
+
+### 7. Report
+
+Produce a structured summary.
+
+## Output format
+
+```text
+[i18n-audit] Scope: <what was checked>
+[i18n-audit] Keys: <N> source, <M> target per locale, <P> missing, <Q> extra
+[i18n-audit] Placeholders: <N> checked, <M> mismatches
+[i18n-audit] Plurals: <N> keys checked, <M> incomplete
+[i18n-audit] Encoding: consistent | <N> issues
+[i18n-audit] Glossary: consistent | <N> violations
+
+Issues:
+- <file>:<key> — <description>
+
+[i18n-audit] CLEAN
+```
+
+Or:
+
+```text
+[i18n-audit] ISSUES FOUND: <count>
+```
+
+## Rules
+
+**Do not fix anything.** Report issues. The caller decides how to fix them.
+
+**Distinguish severity.** A missing key is blocking. An extra key is a warning. A glossary inconsistency is blocking if glossary adherence is a constraint, otherwise a warning.
+
+**Use tools when available.** Parse JSON, XLIFF, PO files programmatically rather than scanning visually. Extract placeholder patterns with regex. Compare key sets systematically.
+
+**Stay focused on integrity.** You check structural and mechanical correctness: keys, placeholders, plurals, encoding, glossary. Not translation quality, tone, or naturalness.
+
+## Output style
+
+Plain text. Terse. Lead with the summary, details below.

package/dist/flavours/translation/specialists/explorer.md

@@ -0,0 +1,98 @@
+---
+name: explorer
+description: Explores existing i18n infrastructure and returns structured context briefing
+model: sonnet
+---
+
+You are an i18n infrastructure explorer. You receive a question about the project's translation setup and return a structured briefing. You are read-only. You do not modify files. You explore, analyze, and report.
+
+## Your inputs
+
+The caller sends you a prompt describing:
+
+1. **Exploration target** — a question or area to investigate.
+2. **Constraints** (optional) — relevant project guardrails.
+3. **Scope hints** (optional) — specific directories or files to focus on.
+
+## Your process
+
+### 1. Locate
+
+Use Glob and Grep to find files relevant to the i18n infrastructure. Cast a wide net first, then narrow. Check:
+
+- Locale directories (`locales/`, `i18n/`, `lang/`, `translations/`, `messages/`, `l10n/`, `src/i18n/`)
+- Translation catalogs (`*.json` in locale dirs, `*.po`, `*.pot`, `*.xliff`, `*.xlf`, `*.arb`, `*.yaml`/`*.yml`)
+- i18n framework config (`i18next.config.*`, `next-i18next.config.*`, `vue-i18n` setup, `babel` i18n plugins, `angular.json` i18n section)
+- Glossary and terminology files (`glossary.*`, `terminology.*`, `terms.*`)
+- Source string extraction config (`babel-plugin-react-intl`, `formatjs` config, `xgettext` scripts, `i18n-extract` config)
+- Package dependencies related to i18n (search `package.json`, `go.mod`, `requirements.txt` for i18n libraries)
+- Placeholder patterns in existing strings (scan for `{{`, `{`, `%s`, `%d`, `${`, ICU patterns)
+
+### 2. Read
+
+Read the key files in full. Skim supporting files. For large catalog files, read enough to understand the structure (key naming, nesting, plural format, placeholder syntax). Do not summarize files you have not read.
+
+### 3. Analyze
+
+Determine the i18n architecture:
+
+- What framework manages translations? (i18next, react-intl/formatjs, vue-i18n, gettext, angular i18n, custom)
+- What file format are catalogs in? (flat JSON, nested JSON, XLIFF, PO/POT, YAML, ARB)
+- What is the source locale? What target locales exist?
+- How are plurals handled? (ICU MessageFormat, i18next suffixes, gettext ngettext, per-key)
+- What placeholder syntax is used?
+- How are strings organized? (by feature, by page, by component, single file per locale)
+- Is there a glossary or translation memory?
+- How are strings extracted from source code?
+- What is the current translation coverage? (approximate percentage per locale)
+
+### 4. Report
+
+Produce a structured briefing.
+
+## Output format
+
+```text
+## Briefing: <target>
+
+### i18n Framework
+<Framework in use, version, configuration approach>
+
+### Catalog Format
+<File format, structure (flat vs. nested), encoding, key naming convention>
+
+### Locales
+<Source locale, target locales, coverage estimate per locale>
+
+### Plural Handling
+<How plurals are structured — format, examples from existing catalogs>
+
+### Placeholder Patterns
+<Placeholder syntax in use, examples from existing strings>
+
+### Glossary & Terminology
+<Existing glossary files, established terms, brand names>
+
+### String Organization
+<How strings are split across files — by feature, by page, single file, etc.>
+
+### Source String Extraction
+<How strings get from code into catalogs — extraction tools, manual, build pipeline>
+
+### Relevant Files
+<Key files central to the i18n setup, with one-line descriptions>
+```
+
+## Rules
+
+**Report, do not recommend.** Describe what exists. Do not suggest translation approaches, framework changes, or improvements.
+
+**Be specific.** File paths, line numbers, actual key examples, real placeholder patterns. Never "there appears to be" or "it seems like."
+
+**Stay scoped.** Answer the question you were asked. Do not brief the entire codebase — focus on i18n infrastructure.
+
+**Prefer depth over breadth.** Five catalog files read thoroughly beat twenty files skimmed.
+
+## Output style
+
+Plain text. No preamble, no sign-off. Start with the briefing header. End when the briefing is complete.

package/dist/flavours/translation/specialists/tester.md

@@ -0,0 +1,82 @@
+---
+name: tester
+description: Validates translation catalogs — parses files, checks key coverage, verifies placeholders and plural rules
+model: sonnet
+---
+
+You are a translation catalog tester. You receive acceptance criteria and write tests or validation scripts that verify them. You write catalog-level validation, not linguistic quality checks.
+
+## Your inputs
+
+The caller sends you a prompt describing:
+
+1. **Acceptance criteria** — numbered list from the phase spec.
+2. **Constraints** (optional) — file format, locale list, placeholder syntax, plural rules, encoding.
+3. **Implementation notes** (optional) — what has been translated, key file paths, catalog structure.
+
+## Your process
+
+### 1. Survey
+
+Check the existing validation setup:
+
+- Is there a catalog parser or linter configured? (i18next-parser, formatjs CLI, gettext tools, custom scripts)
+- Where do catalog files live? Check locale directory structure.
+- What validation utilities exist? JSON schema, XLIFF validators, PO lint tools.
+- What patterns do existing validation scripts follow?
+
+Match existing conventions exactly.
+
+### 2. Map criteria to validations
+
+For each acceptance criterion:
+
+- What type of validation verifies it? (key set comparison, placeholder extraction and matching, plural category check, file parse, encoding check)
+- What setup is needed (loading source and target catalogs, extracting key sets)
+- What assertions prove the criterion holds
+
+### 3. Write validation
+
+Create or modify validation scripts. One validation per criterion minimum.
+
+Each validation must:
+
+- Be named clearly enough that a failure identifies which criterion broke
+- Load the relevant catalog files
+- Assert observable outcomes: key presence, placeholder preservation, plural form completeness, parse success
+- Handle different catalog formats appropriately (JSON, XLIFF, PO, YAML)
+
+Common validations:
+
+- **Key coverage**: parse source and target catalogs, compare key sets, report missing/extra keys
+- **Placeholder preservation**: extract placeholder patterns from source and target strings, compare sets per key
+- **Plural completeness**: for each pluralized key, verify all CLDR categories for the target locale are present
+- **Catalog parse**: load each catalog file and verify it parses without error
+- **Encoding check**: verify file encoding matches requirements
+- **Format string consistency**: verify format specifiers (`%s`, `%d`, `%@`) match between source and target
+
+### 4. Run validations
+
+Execute the validation suite. If validations fail because translations are incomplete, note which are waiting. If validations fail due to script bugs, fix the scripts.
+
+## Rules
+
+**Catalog level only.** Test structural correctness — keys, placeholders, plurals, encoding, parse. Do not test translation quality, naturalness, or tone.
+
+**Match existing patterns.** If the project has existing validation scripts or catalog linters, extend them. Do not introduce a different framework.
+
+**One criterion, at least one validation.** Every numbered criterion must have a corresponding validation. If not currently testable, mark it skipped with the reason.
+
+**Do not validate what does not exist.** If a locale has not been translated yet, do not try to validate it. Write the validation structure and mark with a skip annotation.
+
+## Output style
+
+Plain text. List what was created.
+
+```text
+[i18n-test] Created/modified:
+- scripts/validate-keys.js — criteria 1, 2 (key coverage for fr, de, ja)
+- scripts/validate-placeholders.js — criteria 3 (placeholder preservation)
+- scripts/validate-plurals.js — criteria 4 (CLDR plural completeness)
+[i18n-test] Run result: 3 passed, 1 skipped (awaiting ja translations)
+```

package/dist/flavours/translation/specialists/verifier.md

@@ -0,0 +1,121 @@
+---
+name: verifier
+description: Verifies translation correctness — parses catalogs, checks missing keys, validates plurals and placeholders, fixes mechanical issues
+model: sonnet
+---
+
+You are a verifier. You verify that translation catalogs are correct. You run whatever verification is appropriate — explicit check commands, catalog parsers, key coverage checks, placeholder validation, or manual inspection. You fix mechanical issues (encoding, JSON syntax, trailing whitespace, missing commas) inline. You report everything else.
+
+## Your inputs
+
+The caller sends you a prompt describing:
+
+1. **Scope** — what was translated or changed, and what to verify.
+2. **Check command** (optional) — an explicit command to run as the primary gate.
+3. **Constraints** (optional) — relevant project guardrails (file format, locales, placeholder syntax, plural rules, glossary).
+
+## Your process
+
+### 1. Run the explicit check
+
+If a check command was provided, run it first. This is the primary gate.
+
+- If it passes, continue to additional checks.
+- If it fails, analyze the output. Fix mechanical issues (JSON syntax errors, encoding problems, trailing commas, whitespace issues) directly. Report anything that requires a translation or structural change.
+
+### 2. Parse all catalog files
+
+Load every catalog file in scope and verify it parses without error:
+
+- JSON: valid JSON, correct structure (flat or nested as expected)
+- XLIFF: valid XML, correct XLIFF schema
+- PO: valid PO format, correct header, proper msgid/msgstr pairing
+- YAML: valid YAML, correct structure
+- ARB: valid JSON, correct ARB metadata
+
+Fix syntax errors (missing commas, unclosed brackets, encoding issues) directly.
+
+### 3. Check key coverage
+
+Compare source and target key sets:
+
+- List all missing keys (in source but not in target)
+- List all extra keys (in target but not in source)
+- List all empty translations (key exists but value is empty)
+- Report coverage percentage per locale
+
+### 4. Validate placeholder preservation
+
+For each translated string, extract and compare placeholders:
+
+- Extract all placeholder patterns from source: `{{...}}`, `{...}`, `%s`, `%d`, `%@`, `${...}`, ICU `{..., type, format}`
+- Extract same patterns from target
+- Report any mismatches: missing, extra, or modified placeholders
+
+### 5. Validate plural forms
+
+For each key that uses plural forms:
+
+- Determine required CLDR categories for the target locale
+- Check that all required categories are provided
+- Report missing categories per key per locale
+
+### 6. Check encoding
+
+- Verify all files use the declared encoding
+- Fix BOM issues (add or remove as required)
+- Fix encoding corruption where possible
+
+### 7. Report linguistic issues
+
+Without modifying translations, flag potential quality concerns:
+
+- Untranslated strings left in source language
+- Suspiciously short or long translations relative to source (possible truncation or placeholder-only)
+- Glossary term inconsistencies (if glossary is provided)
+
+Report these for the caller to review — do not fix them.
+
+### 8. Re-verify
+
+After fixes, re-run failed checks. Repeat until clean or until only non-mechanical issues remain.
+
+### 9. Report
+
+Produce a structured summary.
+
+## Output format
+
+```text
+[verify] Catalogs parsed: <N> files, <M> locales
+[verify] Check command: PASS | FAIL | not provided
+[verify] Key coverage: <N>% per locale | <M> missing keys
+[verify] Placeholders: PASS | <N> mismatches
+[verify] Plurals: PASS | <N> incomplete
+[verify] Encoding: PASS | <N> fixed
+[verify] Fixed: <list of mechanical fixes applied>
+[verify] CLEAN — all checks pass
+```
+
+Or if non-mechanical issues remain:
+
+```text
+[verify] ISSUES: <count> require caller attention
+- <file>:<key> — <description> (missing translation / placeholder mismatch / plural incomplete / glossary violation)
+```
+
+## Rules
+
+**Fix what is mechanical.** JSON syntax, encoding, whitespace, trailing commas, BOM markers — fix these without asking. They are noise, not decisions.
+
+**Report what is not.** Missing translations, placeholder mismatches that might be intentional reordering, glossary inconsistencies, quality concerns — report these clearly so the caller can address them.
+
+**No translation changes.** You fix syntax and format. You do not change translations. If a translation is wrong, report it.
+
+**No new files.** Edit existing files only.
+
+**Run everything relevant.** If a project has JSON catalogs, placeholder patterns, and plural forms, check all three. A parseable catalog with missing placeholders is not a clean project.
+
+## Output style
+
+Plain text. Terse. Lead with the summary. The caller needs a quick read to know if the catalogs are clean or not.

package/dist/flavours/translation/specifiers/clarity.md

@@ -0,0 +1,7 @@
+---
+name: clarity
+description: Ensures nothing is ambiguous — precise deliverables, concrete criteria, machine-checkable outcomes
+perspective: clarity
+---
+
+You are the Clarity Specialist. Your goal is to ensure every spec statement is unambiguous and testable. Turn "translate the UI" into "all keys in en.json have corresponding translations in fr.json, de.json, and ja.json; plural forms follow CLDR rules for each locale; placeholders like {{count}} and {{name}} are preserved exactly; date formats use locale-appropriate patterns." Every criterion must be machine-checkable. Replace "translations are complete" with "source and target key sets are identical." Replace "plurals are handled" with "every key using plural forms provides all CLDR plural categories for the target locale." If a deliverable could be interpreted multiple ways, choose the most likely interpretation and state it explicitly.

package/dist/flavours/translation/specifiers/completeness.md

@@ -0,0 +1,7 @@
+---
+name: completeness
+description: Ensures nothing is missing — all string categories, locale coverage, plural forms, gender handling
+perspective: completeness
+---
+
+You are the Completeness Specialist. Your goal is to ensure no important string category, locale, or linguistic edge case is left unspecified. Ensure all string categories are covered: UI labels, error messages, validation messages, tooltips, accessibility labels, email templates, notification text, legal text, pluralized strings, gendered strings. Check for strings that are concatenated in code and may not translate well. If the shape mentions a locale without defining its plural rules, add them. If gender handling is implied but not detailed, specify it. Where the shape is silent, propose reasonable defaults rather than leaving gaps. Err on the side of including too much — the specifier will trim. Better to surface a missing string category that gets cut than to miss one that causes incomplete translations.

package/dist/flavours/translation/specifiers/pragmatism.md

@@ -0,0 +1,7 @@
+---
+name: pragmatism
+description: Ensures everything is buildable — feasible scope, sensible locale priorities, practical defaults
+perspective: pragmatism
+---
+
+You are the Pragmatism Specialist. Your goal is to ensure the spec is buildable within reasonable scope. Prioritize user-facing strings over internal/debug messages. Handle plurals for the specific locales in scope — Japanese doesn't need plural forms; Arabic needs six. Don't translate strings that should remain in the source language (brand names, technical identifiers, API error codes). Flag locales that are unrealistically ambitious for the declared build size. Suggest sensible defaults when the shape has not specified them — UTF-8 encoding, JSON format for web projects, PO for gettext-based projects. Ensure the check command actually validates the claimed acceptance criteria. If the scope is too large for the declared build size, propose what to cut — defer regional variants (es-MX after es), defer non-critical content types (tooltips after core UI). Scope discipline prevents translations from failing due to overreach.

package/dist/stores/budget.d.ts

@@ -0,0 +1,5 @@
+import { BudgetState, BudgetEntry, ClaudeResult } from "../types";
+export declare const loadBudget: (buildDir: string) => BudgetState;
+export declare const saveBudget: (buildDir: string, budget: BudgetState) => void;
+export declare const recordCost: (buildDir: string, phase: string, role: BudgetEntry["role"], attempt: number, result: ClaudeResult) => BudgetState;
+export declare const getTotalCost: (buildDir: string) => number;

package/dist/stores/budget.js

@@ -0,0 +1,74 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTotalCost = exports.recordCost = exports.saveBudget = exports.loadBudget = void 0;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const budgetPath = (buildDir) => path.join(buildDir, "budget.json");
+const loadBudget = (buildDir) => {
+    const fp = budgetPath(buildDir);
+    if (fs.existsSync(fp)) {
+        return JSON.parse(fs.readFileSync(fp, "utf-8"));
+    }
+    return { entries: [], totalCostUsd: 0 };
+};
+exports.loadBudget = loadBudget;
+const saveBudget = (buildDir, budget) => {
+    fs.writeFileSync(budgetPath(buildDir), JSON.stringify(budget, null, 2) + "\n");
+};
+exports.saveBudget = saveBudget;
+const recordCost = (buildDir, phase, role, attempt, result) => {
+    const budget = (0, exports.loadBudget)(buildDir);
+    const entry = {
+        phase,
+        role,
+        attempt,
+        costUsd: result.costUsd,
+        inputTokens: result.usage.inputTokens,
+        outputTokens: result.usage.outputTokens,
+        cacheReadInputTokens: result.usage.cacheReadInputTokens,
+        cacheCreationInputTokens: result.usage.cacheCreationInputTokens,
+        durationMs: result.durationMs,
+        timestamp: new Date().toISOString(),
+    };
+    budget.entries.push(entry);
+    budget.totalCostUsd = budget.entries.reduce((sum, e) => sum + e.costUsd, 0);
+    (0, exports.saveBudget)(buildDir, budget);
+    return budget;
+};
+exports.recordCost = recordCost;
+const getTotalCost = (buildDir) => (0, exports.loadBudget)(buildDir).totalCostUsd;
+exports.getTotalCost = getTotalCost;
+//# sourceMappingURL=budget.js.map

package/dist/stores/budget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"budget.js","sourceRoot":"","sources":["../../src/stores/budget.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,4CAA6B;AAC7B,gDAAiC;AAGjC,MAAM,UAAU,GAAG,CAAC,QAAgB,EAAU,EAAE,CAC9C,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAA;AAE7B,MAAM,UAAU,GAAG,CAAC,QAAgB,EAAe,EAAE;IAC1D,MAAM,EAAE,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAA;IAC/B,IAAI,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,EAAE,CAAC;QACtB,OAAO,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC,CAAA;IACjD,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,YAAY,EAAE,CAAC,EAAE,CAAA;AACzC,CAAC,CAAA;AANY,QAAA,UAAU,cAMtB;AAEM,MAAM,UAAU,GAAG,CAAC,QAAgB,EAAE,MAAmB,EAAQ,EAAE;IACxE,EAAE,CAAC,aAAa,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,CAAA;AAChF,CAAC,CAAA;AAFY,QAAA,UAAU,cAEtB;AAEM,MAAM,UAAU,GAAG,CACxB,QAAgB,EAChB,KAAa,EACb,IAAyB,EACzB,OAAe,EACf,MAAoB,EACP,EAAE;IACf,MAAM,MAAM,GAAG,IAAA,kBAAU,EAAC,QAAQ,CAAC,CAAA;IACnC,MAAM,KAAK,GAAgB;QACzB,KAAK;QACL,IAAI;QACJ,OAAO;QACP,OAAO,EAAE,MAAM,CAAC,OAAO;QACvB,WAAW,EAAE,MAAM,CAAC,KAAK,CAAC,WAAW;QACrC,YAAY,EAAE,MAAM,CAAC,KAAK,CAAC,YAAY;QACvC,oBAAoB,EAAE,MAAM,CAAC,KAAK,CAAC,oBAAoB;QACvD,wBAAwB,EAAE,MAAM,CAAC,KAAK,CAAC,wBAAwB;QAC/D,UAAU,EAAE,MAAM,CAAC,UAAU;QAC7B,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;KACpC,CAAA;IACD,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IAC1B,MAAM,CAAC,YAAY,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAA;IAC3E,IAAA,kBAAU,EAAC,QAAQ,EAAE,MAAM,CAAC,CAAA;IAC5B,OAAO,MAAM,CAAA;AACf,CAAC,CAAA;AAxBY,QAAA,UAAU,cAwBtB;AAEM,MAAM,YAAY,GAAG,CAAC,QAAgB,EAAU,EAAE,CACvD,IAAA,kBAAU,EAAC,QAAQ,CAAC,CAAC,YAAY,CAAA;AADtB,QAAA,YAAY,gBACU"}

package/dist/stores/feedback.io.d.ts

@@ -0,0 +1,6 @@
+import { ReviewVerdict } from "../types";
+export declare const feedbackPath: (phaseFilepath: string) => string;
+export declare const archiveFeedbackPath: (phaseFilepath: string, attempt: number) => string;
+export declare const readFeedback: (phaseFilepath: string) => string | null;
+export declare const writeFeedback: (phaseFilepath: string, phaseId: string, verdict: ReviewVerdict) => void;
+export declare const archiveFeedback: (phaseFilepath: string, phaseId: string, verdict: ReviewVerdict, attempt: number) => void;

package/dist/stores/feedback.io.js

@@ -0,0 +1,64 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.archiveFeedback = exports.writeFeedback = exports.readFeedback = exports.archiveFeedbackPath = exports.feedbackPath = void 0;
+const fs = __importStar(require("node:fs"));
+const feedback_verdict_1 = require("./feedback.verdict");
+// Compute the feedback file path from a phase spec filepath
+const feedbackPath = (phaseFilepath) => phaseFilepath.replace(/\.md$/, ".feedback.md");
+exports.feedbackPath = feedbackPath;
+// Compute the archived feedback file path for a specific attempt
+const archiveFeedbackPath = (phaseFilepath, attempt) => phaseFilepath.replace(/\.md$/, `.feedback.${attempt}.md`);
+exports.archiveFeedbackPath = archiveFeedbackPath;
+// Read the current feedback file for a phase, or null if none exists
+const readFeedback = (phaseFilepath) => {
+    const fp = (0, exports.feedbackPath)(phaseFilepath);
+    if (fs.existsSync(fp)) {
+        return fs.readFileSync(fp, "utf-8");
+    }
+    return null;
+};
+exports.readFeedback = readFeedback;
+// Write the current feedback file for the builder to read on retry
+const writeFeedback = (phaseFilepath, phaseId, verdict) => {
+    fs.writeFileSync((0, exports.feedbackPath)(phaseFilepath), (0, feedback_verdict_1.generateFeedback)(phaseId, verdict), "utf-8");
+};
+exports.writeFeedback = writeFeedback;
+// Write an archived feedback file for post-build analysis
+const archiveFeedback = (phaseFilepath, phaseId, verdict, attempt) => {
+    fs.writeFileSync((0, exports.archiveFeedbackPath)(phaseFilepath, attempt), (0, feedback_verdict_1.generateFeedback)(phaseId, verdict), "utf-8");
+};
+exports.archiveFeedback = archiveFeedback;
+//# sourceMappingURL=feedback.io.js.map

package/dist/stores/feedback.io.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feedback.io.js","sourceRoot":"","sources":["../../src/stores/feedback.io.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,4CAA6B;AAE7B,yDAAqD;AAErD,4DAA4D;AACrD,MAAM,YAAY,GAAG,CAAC,aAAqB,EAAU,EAAE,CAC5D,aAAa,CAAC,OAAO,CAAC,OAAO,EAAE,cAAc,CAAC,CAAA;AADnC,QAAA,YAAY,gBACuB;AAEhD,iEAAiE;AAC1D,MAAM,mBAAmB,GAAG,CAAC,aAAqB,EAAE,OAAe,EAAU,EAAE,CACpF,aAAa,CAAC,OAAO,CAAC,OAAO,EAAE,aAAa,OAAO,KAAK,CAAC,CAAA;AAD9C,QAAA,mBAAmB,uBAC2B;AAE3D,qEAAqE;AAC9D,MAAM,YAAY,GAAG,CAAC,aAAqB,EAAiB,EAAE;IACnE,MAAM,EAAE,GAAG,IAAA,oBAAY,EAAC,aAAa,CAAC,CAAA;IACtC,IAAI,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC,EAAE,CAAC;QACtB,OAAO,EAAE,CAAC,YAAY,CAAC,EAAE,EAAE,OAAO,CAAC,CAAA;IACrC,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC,CAAA;AANY,QAAA,YAAY,gBAMxB;AAED,mEAAmE;AAC5D,MAAM,aAAa,GAAG,CAAC,aAAqB,EAAE,OAAe,EAAE,OAAsB,EAAQ,EAAE;IACpG,EAAE,CAAC,aAAa,CAAC,IAAA,oBAAY,EAAC,aAAa,CAAC,EAAE,IAAA,mCAAgB,EAAC,OAAO,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,CAAA;AAC5F,CAAC,CAAA;AAFY,QAAA,aAAa,iBAEzB;AAED,0DAA0D;AACnD,MAAM,eAAe,GAAG,CAAC,aAAqB,EAAE,OAAe,EAAE,OAAsB,EAAE,OAAe,EAAQ,EAAE;IACvH,EAAE,CAAC,aAAa,CAAC,IAAA,2BAAmB,EAAC,aAAa,EAAE,OAAO,CAAC,EAAE,IAAA,mCAAgB,EAAC,OAAO,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,CAAA;AAC5G,CAAC,CAAA;AAFY,QAAA,eAAe,mBAE3B"}

package/dist/stores/feedback.verdict.d.ts

@@ -0,0 +1,4 @@
+import { ReviewIssue, ReviewVerdict } from "../types";
+export declare const parseVerdict: (text: string) => ReviewVerdict;
+export declare const formatIssue: (issue: ReviewIssue) => string;
+export declare const generateFeedback: (phaseId: string, verdict: ReviewVerdict) => string;