From 0dec20a6fe3c43d3dc4eabd129ac75793de08509 Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 20 Jan 2026 12:32:05 +0000 Subject: [PATCH 1/7] Create Recursive Language Model skill epic Add comprehensive task epic for building RLM skill that applies MIT's Recursive Language Model strategies to AI agent codebase exploration. Epic includes 7 tasks covering research, design, implementation of fan-out search, SQLite indexing, and SudoLang skill specification. --- tasks/recursive-language-model-skill-epic.md | 123 +++++++++++++++++++ 1 file changed, 123 insertions(+) create mode 100644 tasks/recursive-language-model-skill-epic.md diff --git a/tasks/recursive-language-model-skill-epic.md b/tasks/recursive-language-model-skill-epic.md new file mode 100644 index 0000000..799f827 --- /dev/null +++ b/tasks/recursive-language-model-skill-epic.md @@ -0,0 +1,123 @@ +# Recursive Language Model Skill Epic + +**Status**: 📋 PLANNED +**Goal**: Build an AI agent skill that applies Recursive Language Model strategies to provide deep, contextually-aware understanding of complex software projects + +## Overview + +AI agents working on complex software projects often struggle with context limits and incomplete understanding of large codebases. This skill implements Recursive Language Model (RLM) strategies from the MIT paper to enable agents to recursively decompose complex queries, fan out searches across the codebase, and build comprehensive understanding through hierarchical exploration. By treating the project repository as an external environment that can be programmatically examined and recursively explored, agents can deliver more accurate, contextually-aware results regardless of project size. + +--- + +## Research Recursive Language Models + +Study the MIT Recursive Language Models paper and implementation patterns to understand core concepts. + +**Requirements**: +- Given the MIT RLM paper (arxiv.org/html/2512.24601v1), should extract core concepts of recursive decomposition +- Given RLM methodology, should understand how to break down complex tasks hierarchically +- Given RLM implementation examples, should identify patterns for handling long context beyond model windows +- Given RLM strategies, should document how recursive calling and task decomposition work +- Given practical applications, should identify how RLMs apply to code understanding and repository exploration + +--- + +## Define User Journey + +Create a comprehensive user journey for an end user driving an environment-aware AI agent. + +**Requirements**: +- Given persona as end user with complex project, should define pain points around context awareness +- Given user goal of comprehensive repository understanding, should map journey steps +- Given existing productmanager.mdc patterns, should create user journey following project conventions +- Given user journey steps, should identify where RLM strategies provide value +- Given journey map, should save to plan/story-map/ following project structure + +--- + +## Design Skill Architecture + +Design the RLM skill structure using SudoLang syntax and agent skills patterns. + +**Requirements**: +- Given agentskills.io specification, should understand skill structure and invocation patterns +- Given SudoLang syntax from ai/rules/sudolang/, should design skill using proper syntax +- Given RLM decomposition strategy, should define interfaces for recursive exploration +- Given fan-out search requirements, should design search orchestration functions +- Given SQLite indexing needs, should design data storage and retrieval interfaces +- Given skill should integrate with existing ai/rules/ and ai/commands/ patterns +- Given skill complexity, should define clear function signatures and constraints + +--- + +## Implement Fan-Out Search Tools + +Build search tools that combine ripgrep with semantic context for comprehensive code discovery. + +**Requirements**: +- Given text search needs, should implement rg (ripgrep) integration +- Given file discovery needs, should implement file pattern matching +- Given semantic search needs, should design RAG (retrieval-augmented generation) approach +- Given search results, should aggregate and rank by relevance +- Given multiple search strategies, should fan out searches in parallel +- Given search orchestration, should use SudoLang function composition patterns + +--- + +## Implement SQLite Indexing System + +Build SQLite-based system for indexing and retrieving arbitrary project data aligned with user queries. + +**Requirements**: +- Given large tabular data needs, should use SQLite for storage +- Given project context, should index relevant code metadata (files, functions, dependencies) +- Given user queries, should generate SQL for contextual retrieval +- Given query results, should format for agent consumption +- Given indexing strategy, should support incremental updates +- Given database schema, should document structure and query patterns + +--- + +## Create RLM Skill Specification + +Build the complete skill file in SudoLang syntax with all RLM functions and orchestration. + +**Requirements**: +- Given skill structure, should create ai/rules/rlm.mdc file +- Given RLM decomposition, should implement recursive task breakdown functions +- Given fan-out search, should integrate search tools into skill functions +- Given SQLite system, should integrate data retrieval into skill +- Given skill invocation, should define clear entry points and command interface +- Given SudoLang constraints, should use proper syntax (interfaces, functions, constraints) +- Given markdown formatting, should prefer lists and SudoLang over tables +- Given existing please.mdc patterns, should follow similar structure and style +- Given alwaysApply frontmatter, should set appropriately for skill activation + +--- + +## Create Command Interface + +Build /rlm command for easy skill invocation. + +**Requirements**: +- Given existing ai/commands/ patterns, should create ai/commands/rlm.md +- Given command structure, should reference ai/rules/rlm.mdc +- Given command invocation, should provide clear usage instructions +- Given please.mdc commands list, should integrate into command ecosystem +- Given command help, should document parameters and options + +--- + +## Document and Test + +Create comprehensive documentation and validate skill functionality. + +**Requirements**: +- Given skill complexity, should create usage examples and documentation +- Given SudoLang syntax guide from user, should save to ai/rules/sudolang/sudolang-syntax.mdc +- Given skill functions, should document expected inputs and outputs +- Given RLM strategies, should provide examples of recursive decomposition in action +- Given test scenarios, should validate skill can handle complex repository queries +- Given documentation, should explain when and how to use RLM skill vs standard approaches + +--- From 542aa3c9181393466ba1ecb656ade788b3937b0b Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 20 Jan 2026 13:24:09 +0000 Subject: [PATCH 2/7] Add comprehensive RLM skill research documentation Research findings include: - Agent Skills specification from agentskills.io - MIT RLM paper analysis (arXiv 2512.24601) - Implementation architecture for aidd framework - Complete SQLite database design with FTS5 Documents recursive language model strategies for deep codebase exploration through hierarchical task decomposition. --- plan/rlm/agent-skills-spec.md | 226 ++++++++ plan/rlm/database-design.md | 701 ++++++++++++++++++++++++ plan/rlm/implementation-architecture.md | 424 ++++++++++++++ plan/rlm/research-summary.md | 90 +++ plan/rlm/rlm-paper-findings.md | 288 ++++++++++ 5 files changed, 1729 insertions(+) create mode 100644 plan/rlm/agent-skills-spec.md create mode 100644 plan/rlm/database-design.md create mode 100644 plan/rlm/implementation-architecture.md create mode 100644 plan/rlm/research-summary.md create mode 100644 plan/rlm/rlm-paper-findings.md diff --git a/plan/rlm/agent-skills-spec.md b/plan/rlm/agent-skills-spec.md new file mode 100644 index 0000000..3e42355 --- /dev/null +++ b/plan/rlm/agent-skills-spec.md @@ -0,0 +1,226 @@ +# Agent Skills Specification + +**Source**: https://agentskills.io/specification +**Standard**: Open specification by Anthropic +**Adoption**: Microsoft, OpenAI, Atlassian, Figma, Cursor, GitHub, VS Code + +## What Are Agent Skills? + +Skills are self-contained folders that teach AI agents to complete specialized tasks through instructions, scripts, and resources. They enable "dynamic performance improvement on specialized tasks" by providing context-specific guidance that agents can discover and load automatically. + +## Skill Structure + +### Minimal Requirements + +A skill is simply a folder containing a `SKILL.md` file: + +``` +ai/skills/skill-name/ + └── SKILL.md +``` + +### SKILL.md Format + +```markdown +--- +name: skill-identifier +description: Complete explanation of what the skill does and when to use it +--- + +# Skill Instructions + +[Instructions for the AI agent] + +## Examples + +[Usage examples] + +## Guidelines + +[Best practices and constraints] +``` + +## Frontmatter Fields + +### Required Fields + +**name** (string) +- Unique lowercase identifier +- Use hyphens instead of spaces +- Example: `pdf`, `recursive-language-model`, `code-review` + +**description** (string) +- Complete explanation of functionality +- When to use the skill +- What problems it solves +- Used by agents to decide whether to activate the skill + +### Optional Fields + +**license** (string) +- License information for the skill +- Example: `MIT`, `Proprietary`, `Apache-2.0` + +## Skill Organization + +### Directory Structure + +``` +ai/skills/ + ├── pdf/ + │ ├── SKILL.md + │ ├── forms.md # Additional documentation + │ └── reference.md # Advanced features + ├── docx/ + │ └── SKILL.md + └── rlm/ + ├── SKILL.md + └── scripts/ # Optional helper scripts + └── index-codebase.js +``` + +### Supporting Files + +Skills can include: +- Additional markdown documentation +- Helper scripts (Python, JavaScript, etc.) +- Configuration files +- Reference materials +- Templates + +## How Agents Use Skills + +### Discovery + +Compatible agents automatically: +1. Scan skill directories +2. Parse SKILL.md frontmatter +3. Index available skills by name and description + +### Activation + +Agents activate skills when: +- User mentions skill by name +- Task description matches skill purpose +- Skill is marked as always-active (implementation-specific) + +### Invocation + +Once activated, agents: +1. Read skill instructions +2. Follow documented workflows +3. Use provided scripts and tools +4. Apply guidelines and constraints + +## Best Practices + +### Writing Effective Descriptions + +Good descriptions include: +- Clear purpose statement +- Specific use cases +- When NOT to use the skill +- Prerequisites or dependencies + +Example: +```yaml +description: Comprehensive PDF manipulation toolkit for extracting text and tables, + creating new PDFs, merging/splitting documents, and handling forms +``` + +### Structuring Instructions + +Effective skill instructions: +- Start with quick start guide +- Organize by task or workflow +- Include concrete examples +- Provide tool alternatives +- Document common pitfalls + +### Including Resources + +Skills work best when they: +- Reference external documentation +- Provide quick reference tables +- Include code templates +- Link to related skills + +## Platform Support + +### Compatible Tools + +- **Claude Code** - CLI agent with skill support +- **Cursor** - IDE with agent skills integration +- **VS Code Copilot** - GitHub Copilot with skills +- **Claude.ai** - Web interface skill uploads +- **Claude API** - Programmatic skill loading + +### Portability + +Skills are **platform-agnostic**: +- Write once, use across all compatible tools +- No vendor lock-in +- Community skill sharing +- Standard-compliant format + +## Examples + +### Minimal Skill + +```markdown +--- +name: hello +description: Simple greeting skill that demonstrates basic structure +--- + +# Hello Skill + +When asked to greet someone, respond warmly and professionally. + +## Examples + +- "Hello, [name]! How can I help you today?" +- "Welcome, [name]! What would you like to work on?" +``` + +### Complex Skill (PDF) + +The PDF skill demonstrates: +- Multiple tool integrations (pypdf, pdfplumber, reportlab) +- CLI alternatives (pdftotext, qpdf) +- Task-based organization +- Quick reference sections +- Links to additional documentation + +See: https://github.com/anthropics/skills/tree/main/skills/pdf + +## Integration with aidd + +### File Location + +``` +ai/skills/rlm/ + └── SKILL.md +``` + +### Activation Strategy + +For RLM skill: +- **alwaysApply**: true (if supported by implementation) +- **AGENTS.md rule**: "Use RLM skill when needing deep project context" +- **Agent decision**: AI determines when to invoke based on query complexity + +### aidd-Specific Patterns + +Skills in aidd framework can: +- Reference ai/tools/ scripts +- Integrate with existing ai/rules/ patterns +- Use SudoLang syntax for AI directives +- Leverage bun CLI tools for execution + +## References + +- Official specification: https://agentskills.io/specification +- GitHub repository: https://github.com/anthropics/skills +- Template skill: https://github.com/anthropics/skills/tree/main/template +- Community skills: https://github.com/skillmatic-ai/awesome-agent-skills diff --git a/plan/rlm/database-design.md b/plan/rlm/database-design.md new file mode 100644 index 0000000..0dbe46a --- /dev/null +++ b/plan/rlm/database-design.md @@ -0,0 +1,701 @@ +# Database Design for RLM Skill + +**Database**: SQLite 3 with JSON1 + FTS5 extensions +**Location**: `.aidd/index.db` (gitignored) +**Strategy**: Hybrid document + structured storage + +## Design Rationale + +### Why SQLite? + +**Advantages**: +- ✅ **Zero infrastructure** - Single file, no servers +- ✅ **Hybrid flexibility** - SQL + JSON + FTS5 in one database +- ✅ **TDD-friendly** - In-memory mode for fast tests +- ✅ **Bun-native** - better-sqlite3 synchronous API +- ✅ **Portable** - Works everywhere, easy backups +- ✅ **Fast** - Millions of rows, <1ms queries +- ✅ **Recursive queries** - CTEs for graph traversal +- ✅ **Full-text search** - Built-in FTS5 extension + +**vs Alternatives**: +- ❌ **LevelDB/RocksDB** - No query language, manual indexing +- ❌ **MongoDB** - Requires server, overkill for use case +- ❌ **JSON files** - No indexing, slow searches, full scans +- ❌ **Neo4j** - Graph DB overkill, server required + +### Hybrid Strategy + +**Document Storage** (JSON columns): +- Frontmatter from .md/.mdc files +- Flexible schema for different file types +- Preserves original structure + +**Structured Tables**: +- ProductManager.mdc schemas (personas, journeys, stories) +- Normalized for complex queries +- Foreign keys for relationships + +**Full-Text Search** (FTS5): +- Content search across all documents +- Frontmatter text search +- Weighted rankings + +## Complete Schema + +### 1. Documents Table (Frontmatter Index) + +```sql +-- Main document index with flexible JSON storage +CREATE TABLE documents ( + path TEXT PRIMARY KEY, + type TEXT NOT NULL, -- 'rule' | 'command' | 'skill' | 'task' | 'story-map' | 'other' + frontmatter JSON, -- Full YAML frontmatter as JSON + content TEXT, -- Markdown content (without frontmatter) + hash TEXT NOT NULL, -- SHA256 for change detection + indexed_at INTEGER NOT NULL, -- Unix timestamp + file_size INTEGER, + modified_at INTEGER +); + +-- Indexes for common queries +CREATE INDEX idx_documents_type ON documents(type); +CREATE INDEX idx_documents_indexed_at ON documents(indexed_at); +CREATE INDEX idx_documents_modified_at ON documents(modified_at); + +-- JSON field extraction for common frontmatter fields +-- These are computed columns for faster queries +CREATE INDEX idx_documents_description ON documents( + json_extract(frontmatter, '$.description') +); +CREATE INDEX idx_documents_always_apply ON documents( + json_extract(frontmatter, '$.alwaysApply') +); +``` + +### 2. Full-Text Search (FTS5) + +```sql +-- Virtual table for full-text search +CREATE VIRTUAL TABLE documents_fts USING fts5( + path UNINDEXED, -- Don't index path for search (use for results) + type, -- Searchable type field + content, -- Primary search content + frontmatter_text, -- Flattened frontmatter for search + tokenize='porter unicode61' -- Better English stemming +); + +-- Trigger to keep FTS5 in sync with documents table +CREATE TRIGGER documents_fts_insert AFTER INSERT ON documents BEGIN + INSERT INTO documents_fts(path, type, content, frontmatter_text) + VALUES ( + new.path, + new.type, + new.content, + json_extract(new.frontmatter, '$') -- Flatten JSON to text + ); +END; + +CREATE TRIGGER documents_fts_update AFTER UPDATE ON documents BEGIN + UPDATE documents_fts + SET + type = new.type, + content = new.content, + frontmatter_text = json_extract(new.frontmatter, '$') + WHERE path = old.path; +END; + +CREATE TRIGGER documents_fts_delete AFTER DELETE ON documents BEGIN + DELETE FROM documents_fts WHERE path = old.path; +END; +``` + +### 3. Dependencies Table (Import Graph) + +```sql +-- Tracks file dependencies (imports, requires, references) +CREATE TABLE dependencies ( + from_file TEXT NOT NULL, + to_file TEXT NOT NULL, + import_type TEXT NOT NULL, -- 'import' | 'require' | 'reference' | 'link' + line_number INTEGER, -- Where the import appears + import_text TEXT, -- Original import statement + created_at INTEGER NOT NULL, + PRIMARY KEY (from_file, to_file, import_type) +); + +-- Indexes for graph traversal +CREATE INDEX idx_dependencies_from ON dependencies(from_file); +CREATE INDEX idx_dependencies_to ON dependencies(to_file); +CREATE INDEX idx_dependencies_type ON dependencies(import_type); + +-- Recursive CTE for finding all dependencies +-- Example query: +/* +WITH RECURSIVE dep_tree(file, depth) AS ( + SELECT from_file, 0 FROM dependencies WHERE to_file = 'target.js' + UNION ALL + SELECT d.from_file, dt.depth + 1 + FROM dependencies d + JOIN dep_tree dt ON d.to_file = dt.file + WHERE dt.depth < 3 -- Max depth +) +SELECT DISTINCT file, depth FROM dep_tree ORDER BY depth; +*/ +``` + +### 4. ProductManager Schema (Story Maps) + +#### 4.1 Personas + +```sql +CREATE TABLE personas ( + id TEXT PRIMARY KEY, -- CUID2 + name TEXT NOT NULL, + description TEXT, + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + metadata JSON -- Flexible storage for additional fields +); + +CREATE INDEX idx_personas_name ON personas(name); +CREATE INDEX idx_personas_created_at ON personas(created_at); +``` + +#### 4.2 Journeys + +```sql +CREATE TABLE journeys ( + id TEXT PRIMARY KEY, -- CUID2 + name TEXT NOT NULL, + description TEXT, + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + metadata JSON -- domain, owner, etc. +); + +CREATE INDEX idx_journeys_name ON journeys(name); +CREATE INDEX idx_journeys_created_at ON journeys(created_at); + +-- Many-to-many: journeys <-> personas +CREATE TABLE journey_personas ( + journey_id TEXT NOT NULL, + persona_id TEXT NOT NULL, + PRIMARY KEY (journey_id, persona_id), + FOREIGN KEY (journey_id) REFERENCES journeys(id) ON DELETE CASCADE, + FOREIGN KEY (persona_id) REFERENCES personas(id) ON DELETE CASCADE +); + +CREATE INDEX idx_journey_personas_journey ON journey_personas(journey_id); +CREATE INDEX idx_journey_personas_persona ON journey_personas(persona_id); +``` + +#### 4.3 Steps + +```sql +CREATE TABLE steps ( + id TEXT PRIMARY KEY, -- CUID2 + journey_id TEXT NOT NULL, + name TEXT NOT NULL, + description TEXT, + order_index INTEGER NOT NULL, -- Step order in journey + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + metadata JSON, + FOREIGN KEY (journey_id) REFERENCES journeys(id) ON DELETE CASCADE +); + +CREATE INDEX idx_steps_journey ON steps(journey_id); +CREATE INDEX idx_steps_order ON steps(journey_id, order_index); +CREATE INDEX idx_steps_created_at ON steps(created_at); +``` + +#### 4.4 Pain Points + +```sql +CREATE TABLE pain_points ( + id TEXT PRIMARY KEY, -- CUID2 + name TEXT NOT NULL, + description TEXT, + impact INTEGER NOT NULL CHECK(impact BETWEEN 1 AND 10), + frequency INTEGER NOT NULL CHECK(frequency BETWEEN 1 AND 10), + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + metadata JSON +); + +CREATE INDEX idx_pain_points_impact ON pain_points(impact); +CREATE INDEX idx_pain_points_frequency ON pain_points(frequency); +CREATE INDEX idx_pain_points_priority ON pain_points(impact * frequency); -- Computed +``` + +#### 4.5 Stories + +```sql +CREATE TABLE stories ( + id TEXT PRIMARY KEY, -- CUID2 + step_id TEXT, -- Nullable - backlog stories may not be in a step yet + pain_point_id TEXT, + name TEXT NOT NULL, + description TEXT, -- "As a X, I want Y, so that Z" + priority INTEGER, -- Computed: pain_point.impact * pain_point.frequency + status TEXT CHECK(status IN ('backlog', 'inProgress', 'released', 'cancelled')), + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + metadata JSON, -- Mockups, etc. + FOREIGN KEY (step_id) REFERENCES steps(id) ON DELETE SET NULL, + FOREIGN KEY (pain_point_id) REFERENCES pain_points(id) ON DELETE SET NULL +); + +CREATE INDEX idx_stories_step ON stories(step_id); +CREATE INDEX idx_stories_pain_point ON stories(pain_point_id); +CREATE INDEX idx_stories_priority ON stories(priority DESC); +CREATE INDEX idx_stories_status ON stories(status); +CREATE INDEX idx_stories_created_at ON stories(created_at); +``` + +#### 4.6 Functional Requirements + +```sql +CREATE TABLE functional_requirements ( + id TEXT PRIMARY KEY, -- CUID2 + story_id TEXT NOT NULL, + description TEXT NOT NULL, -- "Given X, should Y" + order_index INTEGER NOT NULL, + created_at INTEGER NOT NULL, + metadata JSON, + FOREIGN KEY (story_id) REFERENCES stories(id) ON DELETE CASCADE +); + +CREATE INDEX idx_requirements_story ON functional_requirements(story_id); +CREATE INDEX idx_requirements_order ON functional_requirements(story_id, order_index); +``` + +## Query Patterns + +### 1. Full-Text Search + +```sql +-- Search for documents containing "authentication" +SELECT + d.path, + d.type, + json_extract(d.frontmatter, '$.description') as description, + fts.rank +FROM documents_fts fts +JOIN documents d ON d.path = fts.path +WHERE documents_fts MATCH 'authentication' +ORDER BY rank +LIMIT 50; +``` + +### 2. Metadata Query + +```sql +-- Find all rules with alwaysApply: true +SELECT + path, + json_extract(frontmatter, '$.description') as description +FROM documents +WHERE + type = 'rule' AND + json_extract(frontmatter, '$.alwaysApply') = 'true'; +``` + +### 3. Dependency Traversal + +```sql +-- Find all files that depend on 'src/auth.js' (direct and indirect) +WITH RECURSIVE dependents(file, depth, path_trace) AS ( + -- Base case: direct dependents + SELECT + from_file, + 1, + to_file || ' <- ' || from_file + FROM dependencies + WHERE to_file = 'src/auth.js' + + UNION ALL + + -- Recursive case: indirect dependents + SELECT + d.from_file, + dep.depth + 1, + dep.path_trace || ' <- ' || d.from_file + FROM dependencies d + JOIN dependents dep ON d.to_file = dep.file + WHERE dep.depth < 5 -- Max depth limit +) +SELECT DISTINCT file, MIN(depth) as depth, path_trace +FROM dependents +GROUP BY file +ORDER BY depth, file; +``` + +### 4. Story Priority Query + +```sql +-- Find high-priority stories for a specific persona +SELECT + s.id, + s.name, + s.description, + s.priority, + pp.impact, + pp.frequency, + step.name as step_name, + j.name as journey_name +FROM stories s +JOIN pain_points pp ON s.pain_point_id = pp.id +LEFT JOIN steps step ON s.step_id = step.id +LEFT JOIN journeys j ON step.journey_id = j.id +LEFT JOIN journey_personas jp ON j.id = jp.journey_id +WHERE + jp.persona_id = ? AND + s.status = 'backlog' AND + s.priority > 50 +ORDER BY s.priority DESC +LIMIT 20; +``` + +### 5. Complex JSON Query + +```sql +-- Find documents with specific frontmatter tags +SELECT + path, + json_extract(frontmatter, '$.description') as description, + json_extract(frontmatter, '$.tags') as tags +FROM documents +WHERE + json_type(frontmatter, '$.tags') = 'array' AND + EXISTS ( + SELECT 1 FROM json_each(frontmatter, '$.tags') + WHERE value IN ('security', 'authentication') + ); +``` + +## Indexing Implementation + +### Change Detection + +```javascript +// Only re-index changed files +import crypto from 'crypto'; + +function hashFile(content) { + return crypto.createHash('sha256').update(content).digest('hex'); +} + +function needsReindex(path, content, db) { + const existing = db + .prepare('SELECT hash FROM documents WHERE path = ?') + .get(path); + + if (!existing) return true; + + const currentHash = hashFile(content); + return currentHash !== existing.hash; +} +``` + +### Batch Insertion + +```javascript +// Fast bulk insert with transaction +function indexDocuments(files, db) { + const insert = db.prepare(` + INSERT OR REPLACE INTO documents + (path, type, frontmatter, content, hash, indexed_at, file_size, modified_at) + VALUES (?, ?, ?, ?, ?, ?, ?, ?) + `); + + const insertMany = db.transaction((docs) => { + for (const doc of docs) { + insert.run( + doc.path, + doc.type, + JSON.stringify(doc.frontmatter), + doc.content, + doc.hash, + Date.now(), + doc.size, + doc.modified + ); + } + }); + + insertMany(files); +} +``` + +## Testing Strategy + +### Unit Tests (In-Memory Database) + +```javascript +import Database from 'better-sqlite3'; +import { describe, test, beforeEach } from 'vitest'; +import { equal } from 'riteway'; + +describe('Document indexing', async () => { + let db; + + beforeEach(() => { + // In-memory database for fast tests + db = new Database(':memory:'); + createSchema(db); // Apply schema + }); + + test('indexDocument() should store frontmatter as JSON', () => { + const doc = { + path: 'test.md', + type: 'rule', + frontmatter: { description: 'Test rule' }, + content: 'Content here', + hash: 'abc123' + }; + + indexDocument(doc, db); + + const result = db + .prepare('SELECT * FROM documents WHERE path = ?') + .get('test.md'); + + equal( + JSON.parse(result.frontmatter).description, + 'Test rule', + 'Should store frontmatter as JSON' + ); + }); + + test('FTS5 search should find documents by content', () => { + indexDocument({ + path: 'auth.md', + type: 'rule', + frontmatter: {}, + content: 'Authentication rules for login', + hash: 'def456' + }, db); + + const results = db + .prepare(` + SELECT d.path FROM documents_fts fts + JOIN documents d ON d.path = fts.path + WHERE documents_fts MATCH ? + `) + .all('authentication'); + + equal(results.length, 1, 'Should find document by content'); + equal(results[0].path, 'auth.md', 'Should return correct path'); + }); +}); +``` + +### Integration Tests (Real Database) + +```javascript +describe('Integration: Full indexing workflow', () => { + test('Should index all aidd .mdc files', async () => { + const db = new Database('.aidd/test-index.db'); + createSchema(db); + + // Index real aidd files + await indexAllFiles('ai/**/*.mdc', db); + + // Verify expected files exist + const count = db + .prepare('SELECT COUNT(*) as count FROM documents') + .get(); + + assert(count.count > 10, 'Should index multiple files'); + + // Verify FTS5 works + const searchResults = db + .prepare(` + SELECT d.path FROM documents_fts fts + JOIN documents d ON d.path = fts.path + WHERE documents_fts MATCH ? + `) + .all('please.mdc'); + + assert(searchResults.length > 0, 'Should find please.mdc via FTS5'); + }); +}); +``` + +## Performance Characteristics + +### Indexing Performance + +**Expected**: +- 100 files: ~100ms +- 1,000 files: ~1s +- 10,000 files: ~10s + +**Optimizations**: +- Transaction batching (10x faster) +- Hash-based change detection (only re-index changed files) +- Parallel file reading (Bun is fast) + +### Query Performance + +**FTS5 Search**: +- Simple query: <10ms +- Complex query: <100ms +- With sorting/ranking: <200ms + +**Dependency Traversal**: +- Depth 1: <10ms +- Depth 3: <50ms +- Depth 5: <100ms + +**JSON Extraction**: +- Simple field: <1ms +- Complex nested query: <10ms + +### Database Size + +**Expected**: +- 100 files: ~500KB +- 1,000 files: ~5MB +- 10,000 files: ~50MB + +FTS5 index adds ~30% overhead + +## Migration Strategy + +### Schema Versioning + +```sql +-- Track schema version +CREATE TABLE schema_version ( + version INTEGER PRIMARY KEY, + applied_at INTEGER NOT NULL +); + +INSERT INTO schema_version (version, applied_at) VALUES (1, unixepoch()); +``` + +### Future Migrations + +```javascript +// Migration framework +const migrations = [ + { + version: 2, + up: (db) => { + db.exec(` + ALTER TABLE documents ADD COLUMN git_hash TEXT; + CREATE INDEX idx_documents_git_hash ON documents(git_hash); + `); + } + }, + // ... more migrations +]; + +function migrate(db) { + const current = db + .prepare('SELECT MAX(version) as v FROM schema_version') + .get().v || 0; + + for (const migration of migrations) { + if (migration.version > current) { + db.transaction(() => { + migration.up(db); + db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)') + .run(migration.version, Date.now()); + })(); + } + } +} +``` + +## Future Enhancements + +### 1. Vector Search (sqlite-vec) + +```sql +-- Add vector embeddings for semantic search +CREATE VIRTUAL TABLE document_embeddings USING vec0( + path TEXT PRIMARY KEY, + embedding FLOAT[1536] -- OpenAI ada-002 dimensions +); + +-- Semantic search query +SELECT + d.path, + d.type, + vec_distance_cosine(de.embedding, ?) as similarity +FROM document_embeddings de +JOIN documents d ON d.path = de.path +ORDER BY similarity DESC +LIMIT 10; +``` + +### 2. Code AST Analysis + +```sql +-- Store parsed code structure +CREATE TABLE code_symbols ( + id TEXT PRIMARY KEY, + file_path TEXT NOT NULL, + symbol_type TEXT NOT NULL, -- 'function' | 'class' | 'variable' | 'import' + name TEXT NOT NULL, + line_start INTEGER NOT NULL, + line_end INTEGER, + scope TEXT, -- 'global' | 'module' | 'local' + signature TEXT, -- Function/method signature + metadata JSON, + FOREIGN KEY (file_path) REFERENCES documents(path) +); + +CREATE INDEX idx_code_symbols_file ON code_symbols(file_path); +CREATE INDEX idx_code_symbols_type ON code_symbols(symbol_type); +CREATE INDEX idx_code_symbols_name ON code_symbols(name); +``` + +### 3. Git History Integration + +```sql +-- Track file change history +CREATE TABLE file_history ( + id TEXT PRIMARY KEY, + file_path TEXT NOT NULL, + commit_hash TEXT NOT NULL, + author TEXT, + timestamp INTEGER NOT NULL, + change_type TEXT, -- 'add' | 'modify' | 'delete' + lines_added INTEGER, + lines_removed INTEGER, + FOREIGN KEY (file_path) REFERENCES documents(path) +); + +-- Find frequently changed files (hotspots) +SELECT + file_path, + COUNT(*) as change_count, + SUM(lines_added + lines_removed) as churn +FROM file_history +WHERE timestamp > unixepoch() - 7776000 -- Last 90 days +GROUP BY file_path +ORDER BY change_count DESC +LIMIT 20; +``` + +## Summary + +**Database design enables**: +- ✅ Fast full-text search across all documents +- ✅ Flexible JSON storage for varying schemas +- ✅ Structured queries for productmanager.mdc data +- ✅ Recursive dependency traversal +- ✅ Incremental indexing with change detection +- ✅ TDD-friendly in-memory testing +- ✅ Future extensibility (vectors, AST, git) + +**Next steps**: +1. Implement schema creation script +2. Build indexer with tests +3. Create query CLI tools +4. Integrate with RLM skill diff --git a/plan/rlm/implementation-architecture.md b/plan/rlm/implementation-architecture.md new file mode 100644 index 0000000..87ee90e --- /dev/null +++ b/plan/rlm/implementation-architecture.md @@ -0,0 +1,424 @@ +# RLM Implementation Architecture for aidd + +**Goal**: Adapt Recursive Language Model strategies for aidd framework to enable deep codebase understanding through hierarchical exploration. + +## Core Architecture Principles + +### Hybrid Approach + +**Symbolic Processing** (Bun/JavaScript with TDD): +- Frontmatter extraction and indexing +- Database management +- Structured queries +- Graph traversal +- CLI tool orchestration + +**AI Intelligence** (SudoLang Skill): +- Recursive decomposition strategy +- Query planning +- Semantic summarization +- Result synthesis +- Decision-making + +### Division of Labor + +| Task Type | Implementation | Example | +|-----------|---------------|---------| +| Extract structured data | JavaScript/Bun | Parse YAML frontmatter | +| Index metadata | JavaScript/Bun | Build SQLite FTS5 index | +| Execute queries | JavaScript/Bun | SQL + FTS5 search | +| Trace dependencies | JavaScript/Bun | Graph traversal algorithm | +| Plan decomposition | AI/SudoLang | Break complex query into sub-queries | +| Semantic search | AI/RAG | "Find files related to authentication" | +| Summarize findings | AI/SudoLang | Synthesize results into coherent answer | +| Decide recursion depth | AI/SudoLang | "Is this complex enough to decompose?" | + +## RLM Concept Translation + +### From REPL to aidd Tools + +**RLM Pattern → aidd Implementation** + +1. **Load input as variable in REPL** + - aidd: Index codebase in SQLite + - Result: Queryable metadata database + +2. **Programmatic examination** + - aidd: CLI query tools + existing Grep/Glob + - Result: Structured search capabilities + +3. **Recursive decomposition** + - aidd: SudoLang functions that fan out searches + - Result: Hierarchical exploration + +4. **Self-invocation over snippets** + - aidd: Agent makes multiple targeted queries + - Result: Focused context gathering + +5. **Result aggregation** + - aidd: AI synthesizes findings + - Result: Coherent answers from distributed data + +## Component Architecture + +### 1. Indexing Layer (JavaScript/Bun) + +**Purpose**: Transform codebase into queryable database + +**Tools**: +- `ai/tools/index-frontmatter.js` - Extract YAML from all .md/.mdc files +- `ai/tools/index-dependencies.js` - Build import graph +- `ai/tools/index-story-maps.js` - Parse productmanager.mdc data + +**Workflow**: +```bash +# Run on pre-commit hook or manual trigger +bun ai/tools/index-frontmatter.js +bun ai/tools/index-dependencies.js +bun ai/tools/index-story-maps.js + +# Result: .aidd/index.db with searchable metadata +``` + +**Testing**: +- Unit tests with vitest +- In-memory SQLite for fast tests +- Fixture files for test data +- TDD approach for all indexers + +### 2. Query Layer (JavaScript/Bun) + +**Purpose**: Provide CLI tools for structured searches + +**Tools**: +- `ai/tools/query-codebase.js` - SQL + FTS5 search +- `ai/tools/find-related.js` - Dependency traversal +- `ai/tools/get-metadata.js` - Extract frontmatter fields + +**Interface**: +```bash +# Text search +bun ai/tools/query-codebase.js "authentication rules" + +# Metadata query +bun ai/tools/get-metadata.js --type=rule --tag=security + +# Dependency trace +bun ai/tools/find-related.js src/auth/login.js --depth=3 + +# Result: JSON output for agent consumption +``` + +**Testing**: +- Unit tests for query logic +- Integration tests with sample database +- Output format validation + +### 3. RLM Skill Layer (SudoLang) + +**Purpose**: Provide AI with recursive exploration strategy + +**Location**: `ai/skills/rlm/SKILL.md` + +**Structure**: +```markdown +--- +name: rlm +description: Use when needing deep project context through recursive codebase exploration +--- + +# Recursive Language Model Skill + +## Recursive Decomposition Strategy + +fn exploreCodebase(query, depth = 0, maxDepth = 3) { + Constraints { + Stop recursion if depth >= maxDepth + Stop if query is simple enough for direct answer + } + + // 1. Analyze query complexity + if (isSimpleQuery(query)) { + return directSearch(query) + } + + // 2. Decompose into sub-queries + subQueries = decomposeQuery(query) + + // 3. Fan out parallel searches + results = [] + for each (subQuery in subQueries) { + parallel { + // Symbolic queries + keywordResults = bun ai/tools/query-codebase.js "$subQuery" + + // Semantic search (built-in RAG) + semanticResults = semanticSearch(subQuery) + + // Recursive exploration if needed + if (requiresDeeperContext(subQuery)) { + deepResults = exploreCodebase(subQuery, depth + 1) + } + } + results.append(aggregateResults(...)) + } + + // 4. Synthesize findings + return synthesize(results) +} + +## Available Tools + +### Symbolic Tools (CLI) +- query-codebase.js - SQLite FTS5 keyword search +- find-related.js - Dependency graph traversal +- get-metadata.js - Frontmatter field extraction + +### Built-in Tools +- Grep - Pattern matching across files +- Glob - File discovery by pattern +- Read - Examine specific files +- RAG - Semantic search (built-in) + +### When to Use + +Use RLM skill when: +- Query spans multiple files or modules +- Need to understand complex flows +- Tracing dependencies or call chains +- Building architectural understanding +- Finding all instances of a pattern + +Don't use RLM when: +- Query targets single file +- Simple keyword search sufficient +- Already have small relevant context +``` + +### 4. AGENTS.md Integration + +**Purpose**: Provide agents with usage guidelines + +**Addition to AGENTS.md**: +```markdown +## Project Context Exploration + +When you need comprehensive understanding of complex project areas: + +1. **Assess complexity**: Can this be answered with simple search? + +2. **Use RLM skill**: For complex queries requiring deep exploration + - Skill is always loaded (alwaysApply: true) + - You decide when to activate based on query needs + +3. **Recursive strategy**: + - Decompose query into sub-queries + - Fan out searches using available tools + - Recursively explore areas needing deeper context + - Aggregate findings into coherent answer + +4. **Tools available**: + - `bun ai/tools/query-codebase.js "keywords"` - Structured search + - `bun ai/tools/find-related.js ` - Dependency traversal + - Built-in Grep/Glob/Read - File exploration + - Built-in RAG - Semantic search + +Example: "How does authentication work?" +→ Decompose: ["Find auth files", "Trace login flow", "Find session management"] +→ Fan out searches for each sub-query +→ Recursively explore dependencies +→ Synthesize into complete auth flow explanation +``` + +## File Structure + +``` +aidd/ +├── ai/ +│ ├── skills/ +│ │ └── rlm/ +│ │ └── SKILL.md # RLM skill specification +│ ├── tools/ +│ │ ├── index-frontmatter.js # Indexing tools +│ │ ├── index-frontmatter.test.js +│ │ ├── index-dependencies.js +│ │ ├── index-dependencies.test.js +│ │ ├── query-codebase.js # Query tools +│ │ ├── query-codebase.test.js +│ │ ├── find-related.js +│ │ └── find-related.test.js +│ └── rules/ +│ └── ... (existing) +├── plan/ +│ └── rlm/ +│ ├── research-summary.md +│ ├── agent-skills-spec.md +│ ├── rlm-paper-findings.md +│ ├── implementation-architecture.md (this file) +│ └── database-design.md +├── .aidd/ +│ └── index.db # SQLite database (gitignored) +├── AGENTS.md # Updated with RLM guidelines +└── package.json # Updated with bun scripts +``` + +## Database Architecture + +See: `database-design.md` for complete schema details + +**Overview**: +- SQLite with JSON1 + FTS5 extensions +- Hybrid structure: documents + structured tables +- Full-text search for content +- Normalized tables for productmanager.mdc schemas +- Dependency graph storage + +## Skill Activation Strategy + +**Decision**: Always-surfaced with agent self-direction + +**Rationale**: +- ✅ Skill always loaded (alwaysApply: true in frontmatter) +- ✅ AGENTS.md provides explicit usage rule +- ✅ Agent decides when to invoke based on query complexity +- ✅ No user friction - automatic and intelligent +- ✅ Agent learns patterns through experience + +**vs On-Demand**: +- ❌ On-demand requires user to remember `/rlm` command +- ❌ Adds friction to workflow +- ❌ Agent can't proactively use when needed + +## Development Workflow + +### Phase 1: Database Foundation +1. Create SQLite schema +2. Build frontmatter indexer with tests +3. Test with real aidd .md/.mdc files +4. Validate FTS5 search quality + +### Phase 2: Query Tools +1. Build CLI query interface +2. Implement dependency traversal +3. Add metadata extraction +4. Test with real queries + +### Phase 3: RLM Skill +1. Write SKILL.md in SudoLang +2. Document decomposition patterns +3. Provide usage examples +4. Test with agent self-prompting + +### Phase 4: Integration +1. Update AGENTS.md +2. Add npm/bun scripts +3. Create pre-commit hook for indexing +4. Document for users + +## Testing Strategy + +### JavaScript/Bun (Unit Tests) +```javascript +// Vitest with riteway assertions +import { describe, test } from 'vitest'; +import { equal } from 'riteway'; + +test('indexFrontmatter() should extract YAML from markdown', async () => { + const input = `--- +description: test +--- +# Content`; + + const result = await indexFrontmatter(input); + + equal(result.frontmatter.description, 'test'); +}); +``` + +### SudoLang (Self-Prompting) +``` +Test: "Can you explain how the productmanager.mdc workflow works?" + +Expected behavior: +1. Agent recognizes complexity +2. Decomposes into sub-queries +3. Uses query tools to find related files +4. Synthesizes explanation from findings +``` + +## Performance Considerations + +### Indexing +- **Frequency**: Pre-commit hook + manual trigger +- **Speed**: ~100ms for 100 files (SQLite is fast) +- **Storage**: ~1MB per 1000 files +- **Incremental**: Hash-based change detection + +### Querying +- **FTS5 Search**: ~10ms for typical queries +- **Dependency Traversal**: O(n*d) where n=nodes, d=depth +- **Result Size**: Limit to top 50 results per query + +### Recursive Exploration +- **Max Depth**: 3 levels (configurable) +- **Parallelization**: Fan out searches in parallel +- **Cost**: More API calls but better quality +- **Caching**: SQLite acts as cache for metadata + +## Extension Points + +### Future Enhancements + +**1. Semantic Embeddings**: +- Add vector search for better semantic matching +- Use sqlite-vec extension +- Generate embeddings for code snippets + +**2. Code Analysis**: +- Parse JavaScript/TypeScript AST +- Index function signatures +- Track variable usage + +**3. Test Coverage**: +- Map tests to source files +- Identify untested code +- Suggest test improvements + +**4. Change Impact**: +- Track git history in database +- Identify frequently-changed files +- Predict change impact radius + +## Success Criteria + +**RLM skill is successful when**: + +1. **Agent uses it appropriately** + - Activates for complex queries + - Doesn't use for simple questions + - Correctly decomposes problems + +2. **Query quality improves** + - Better answers for complex questions + - Handles large codebase exploration + - Finds relevant context efficiently + +3. **Developer productivity** + - Faster onboarding to codebase + - Better architectural understanding + - Reduced context switching + +4. **System performance** + - Indexing completes in <5 seconds + - Queries return in <1 second + - Reasonable API call costs + +## Next Steps + +1. Create user journey (Task 2 from epic) +2. Build database schema (see database-design.md) +3. Implement indexer with TDD +4. Build query tools +5. Write RLM skill +6. Update AGENTS.md +7. Test and iterate diff --git a/plan/rlm/research-summary.md b/plan/rlm/research-summary.md new file mode 100644 index 0000000..7902cc5 --- /dev/null +++ b/plan/rlm/research-summary.md @@ -0,0 +1,90 @@ +# RLM Skill Research Summary + +**Epic**: Recursive Language Model Skill for aidd Framework +**Date**: 2026-01-20 +**Status**: Research Complete + +## Overview + +Research completed on Agent Skills specification and MIT's Recursive Language Models paper to build an RLM skill that enables AI agents to deeply understand complex codebases through hierarchical task decomposition. + +## Key Research Areas + +1. **Agent Skills Specification** (agentskills.io) +2. **MIT Recursive Language Models Paper** (arXiv 2512.24601) +3. **RLM Implementation Patterns** (alexzhang13/rlm) +4. **aidd Framework Integration Strategy** + +## Core Findings + +### Agent Skills Format + +Agent Skills are simple, discoverable folders containing: +- **SKILL.md** file with YAML frontmatter + markdown instructions +- Optional scripts and resources +- Minimal required fields: `name` and `description` + +Skills are auto-loaded by compatible agents (Claude Code, Cursor, VS Code Copilot) and provide specialized task guidance. + +### Recursive Language Models Concept + +RLMs enable language models to handle near-infinite context by: +- **Treating input as external environment** rather than stuffing into context window +- **Programmatic examination** through code execution +- **Recursive decomposition** of complex queries into sub-queries +- **Self-invocation** over smaller snippets +- **Result aggregation** back up the call stack + +**Performance**: Handles inputs 2 orders of magnitude beyond context windows with dramatically better quality. + +### aidd Adaptation Strategy + +aidd framework already provides REPL-like capabilities through: +- Grep/Glob tools for programmatic search +- Read tool for snippet examination +- Built-in RAG for semantic search +- Bash tool for symbolic execution + +**RLM Enhancement**: Add SQLite-based indexing + query tools to enable structured, recursive exploration of codebase metadata. + +## Implementation Architecture + +### Hybrid Approach + +**JavaScript/Bun with TDD** (Symbolic Processing): +- Frontmatter extraction and indexing +- SQLite database management +- FTS5 full-text search +- Dependency graph traversal +- CLI query tools + +**SudoLang Skill** (AI Intelligence): +- Recursive decomposition strategy +- Query planning and orchestration +- Semantic summarization +- Result aggregation + +### Database Strategy + +**SQLite with JSON + FTS5 extensions**: +- Document storage with JSON columns for flexible schema +- Full-text search for content exploration +- Recursive CTEs for graph traversal +- Lightweight, portable, TDD-friendly + +## Next Steps + +1. Create user journey mapping pain points and workflows +2. Build SQLite indexer with comprehensive tests +3. Implement query CLI tools +4. Write RLM skill in SudoLang +5. Update AGENTS.md with usage guidelines +6. Test recursive exploration patterns + +## References + +- [Agent Skills Specification](https://agentskills.io/specification) +- [Anthropic Skills GitHub](https://github.com/anthropics/skills) +- [Recursive Language Models Paper](https://arxiv.org/abs/2512.24601) +- [RLM GitHub Implementation](https://github.com/alexzhang13/rlm) +- [Agent Skills Overview](https://simonwillison.net/2025/Dec/19/agent-skills/) diff --git a/plan/rlm/rlm-paper-findings.md b/plan/rlm/rlm-paper-findings.md new file mode 100644 index 0000000..0205045 --- /dev/null +++ b/plan/rlm/rlm-paper-findings.md @@ -0,0 +1,288 @@ +# Recursive Language Models: Paper Findings + +**Paper**: Recursive Language Models +**Authors**: Alex L. Zhang, Tim Kraska, Omar Khattab (MIT CSAIL) +**Published**: December 31, 2025 +**arXiv**: 2512.24601 +**Source**: https://arxiv.org/abs/2512.24601 + +## Abstract + +The paper addresses **context rot** - the phenomenon where even frontier models like GPT-5 degrade quickly as context gets longer. RLMs propose a general inference strategy that treats long prompts as part of an external environment, allowing the LLM to programmatically examine, decompose, and recursively call itself over snippets of the prompt. + +## Core Problem: Context Rot + +**Challenge**: LLM quality degrades dramatically with long context +- Even state-of-the-art models struggle beyond certain context lengths +- Simply extending context windows doesn't solve quality degradation +- Need: Dramatically scale context size by orders of magnitude + +**Question**: Can we scale general-purpose LLM context beyond model limits? + +## Solution: Recursive Language Models + +### Key Innovation + +Instead of stuffing everything into the context window: +1. **Load input as a variable** in a programming environment (REPL) +2. **Programmatically examine** the input through code +3. **Decompose** complex queries into simpler sub-queries +4. **Recursively invoke** the LLM over smaller snippets +5. **Aggregate results** back through the call stack + +### Architecture + +**Traditional LLM Call**: +```python +response = llm.completion(prompt, model) +``` + +**RLM Call**: +```python +# Prompt becomes a variable in REPL +response = rlm.completion(prompt, model) +# Model can now: +# - peek into prompt programmatically +# - decompose it into parts +# - recursively call itself over snippets +# - aggregate results +``` + +### REPL Environment + +RLMs use a Python REPL sandbox where: +- Long input is loaded as a variable (not in context) +- Model writes code to examine the variable +- Model launches sub-calls through code +- Results accumulate in the REPL state +- Final answer synthesized from sub-results + +## Performance Results + +**Context Scaling**: +- Handles inputs **2 orders of magnitude** beyond model context windows +- Successfully processes 100x longer contexts than base models + +**Quality Improvements**: +- Dramatically outperforms base LLM quality on long-context tasks +- Tested across 4 diverse long-context benchmarks +- Maintains quality at extreme context lengths + +## Recursive Decomposition Strategy + +### Pattern Recognition + +Model learns to: +1. **Identify complexity** - "Is this query too complex for one call?" +2. **Decompose hierarchically** - Break into logical sub-problems +3. **Plan execution** - Determine order and dependencies +4. **Execute recursively** - Launch sub-calls in REPL +5. **Aggregate intelligently** - Combine results into coherent answer + +### Example Flow + +**Query**: "Summarize all authentication flows in this codebase" + +**RLM Decomposition**: +```python +# Step 1: Load codebase as variable +codebase = load_input(prompt) + +# Step 2: Find relevant files +auth_files = code.execute("find files matching 'auth'") + +# Step 3: Recursively process each file +summaries = [] +for file in auth_files: + summary = rlm.completion(f"Summarize auth flow in {file}") + summaries.append(summary) + +# Step 4: Aggregate +final_summary = rlm.completion(f"Synthesize these summaries: {summaries}") + +return final_summary +``` + +## Implementation Details + +### Sandboxing Options + +**Non-Isolated**: +- LocalREPL: Same process, shared virtual environment +- Fast but less secure +- Good for development and trusted inputs + +**Isolated**: +- DockerREPL: Containerized execution +- Modal: Cloud sandboxes +- Prime Sandboxes: Beta cloud option +- Secure but slower + +### Logging and Debugging + +**RLMLogger**: +- Records full trajectory of recursive calls +- Visualizes call tree +- Shows code execution, sub-LM calls, root-LM calls +- Essential for debugging complex decompositions + +### Backend Support + +Works with multiple LLM backends: +- OpenAI (GPT models) +- Anthropic (Claude) +- OpenRouter +- Portkey +- LiteLLM +- Local models + +## Key Insights for aidd + +### 1. External Environment Pattern + +**RLM Concept**: Treat long context as external environment +**aidd Translation**: Codebase is external environment + +Instead of reading entire codebase into context: +- Index codebase metadata in SQLite +- Query programmatically +- Recursively explore relevant areas +- Aggregate findings + +### 2. Programmatic Examination + +**RLM Concept**: Write code to peek into input variable +**aidd Translation**: Query tools examine codebase + +RLM uses Python REPL, aidd uses: +- Grep/Glob for search +- SQLite for structured queries +- Read for snippet examination +- Bash for symbolic execution + +### 3. Recursive Decomposition + +**RLM Concept**: Break complex queries into sub-queries +**aidd Translation**: Hierarchical codebase exploration + +Example: +- "Find auth flow" → + - "Find auth files" + - "Trace dependencies" + - "Extract logic" + - "Synthesize flow" + +### 4. Result Aggregation + +**RLM Concept**: Combine sub-results into final answer +**aidd Translation**: Semantic summarization of findings + +Use AI for: +- Synthesizing search results +- Identifying patterns +- Drawing conclusions +- Generating explanations + +## Application to Code Understanding + +### Why RLMs Excel at Code + +**Code characteristics**: +- Highly structured +- Hierarchical organization +- Clear boundaries (files, functions, modules) +- Explicit dependencies +- Searchable patterns + +**RLM advantages**: +- Natural decomposition by file/module +- Programmatic traversal of imports +- Recursive exploration of call chains +- Aggregation of module summaries + +### Strategies for Codebase Exploration + +**1. Top-Down Exploration**: +``` +Query: "How does authentication work?" +→ Find auth-related files +→ For each file, extract key functions +→ For each function, trace dependencies +→ Synthesize into flow diagram +``` + +**2. Bottom-Up Search**: +``` +Query: "Where is password hashing used?" +→ Search for hash/bcrypt/crypto +→ Identify usage locations +→ Trace upward to calling functions +→ Build usage map +``` + +**3. Dependency Traversal**: +``` +Query: "What depends on database module?" +→ Find all imports of database +→ For each importer, find its importers +→ Build dependency tree +→ Identify high-impact modules +``` + +## Implementation Recommendations + +### For aidd RLM Skill + +**1. Build Query Infrastructure**: +- SQLite indexing for fast lookups +- FTS5 for full-text search +- Dependency graph storage + +**2. Implement Decomposition Functions**: +- Define common exploration patterns +- Create SudoLang functions for recursive logic +- Build CLI tools for symbolic queries + +**3. Enable Agent Intelligence**: +- Agent decides when to use RLM +- Agent plans decomposition strategy +- Agent synthesizes results + +**4. Provide Clear Guidelines**: +- Document when to use RLM vs simple search +- Show example decompositions +- Explain performance trade-offs + +## Performance Considerations + +**When to Use RLMs**: +- ✅ Complex queries spanning multiple files +- ✅ Deep dependency traversal +- ✅ Pattern finding across large codebase +- ✅ Architectural understanding + +**When NOT to Use**: +- ❌ Simple file content questions +- ❌ Single-location lookups +- ❌ Already have small relevant context + +**Trade-offs**: +- More API calls (cost) +- Longer total execution time +- Better final quality +- Handles unlimited context + +## References + +### Primary Sources +- Paper: https://arxiv.org/abs/2512.24601 +- Implementation: https://github.com/alexzhang13/rlm +- Blog post: https://alexzhang13.github.io/blog/2025/rlm/ + +### Analysis +- Prime Intellect: https://www.primeintellect.ai/blog/rlm +- MarkTechPost: https://www.marktechpost.com/2026/01/02/recursive-language-models-rlms-from-mits-blueprint-to-prime-intellects-rlmenv-for-long-horizon-llm-agents/ + +### Related Work +- HuggingFace: https://huggingface.co/papers/2512.24601 +- AlphaXiv: https://www.alphaxiv.org/resources/2512.24601v1 From d476097668566351eb4044b402e5bb020b6f1564 Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 20 Jan 2026 14:01:51 +0000 Subject: [PATCH 3/7] Create 5-phase epic structure for RLM + DB + Jiron skills MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Replace single RLM epic with comprehensive phase-based approach: Phase 1: SQLite Foundation + Indexing + Fan-out Search - Database schema for documents, dependencies, productmanager - Frontmatter and dependency indexers with TDD - Fan-out search combining keyword, semantic, structured - CLI query and indexing tools Phase 2: Jiron DB API Skill - Generic skill for SudoLang → Jiron API generation - SQLite query bridge and middleware integration - Fan-out search exposed via Jiron endpoints - Includes ai/skills/jiron skill to teach agents Jiron protocol Phase 3: Frontmatter Index Jiron API - Apply Jiron DB API skill to frontmatter/codebase index - Self-documenting API with progressive discovery - Search and traversal endpoints with rich queries Phase 4: ProductManager Skill Conversion - Convert ai/rules/productmanager.mdc to full skill - Jiron API for story maps with SQLite as source of truth - Import existing YAML, export on demand - Database-backed workflows Phase 5: RLM Skill - Recursive exploration through hierarchical decomposition - Orchestrates all previous phases - User journey documented with pain points - Always-surfaced skill with agent self-direction Archived original RLM epic for reference. --- ...20-recursive-language-model-skill-epic.md} | 0 tasks/phase-1-sqlite-foundation.md | 272 ++++++++ tasks/phase-2-jiron-db-api-skill.md | 373 +++++++++++ tasks/phase-3-frontmatter-jiron-api.md | 313 ++++++++++ tasks/phase-4-productmanager-skill.md | 413 +++++++++++++ tasks/phase-5-rlm-skill.md | 582 ++++++++++++++++++ 6 files changed, 1953 insertions(+) rename tasks/{recursive-language-model-skill-epic.md => archive/2026-01-20-recursive-language-model-skill-epic.md} (100%) create mode 100644 tasks/phase-1-sqlite-foundation.md create mode 100644 tasks/phase-2-jiron-db-api-skill.md create mode 100644 tasks/phase-3-frontmatter-jiron-api.md create mode 100644 tasks/phase-4-productmanager-skill.md create mode 100644 tasks/phase-5-rlm-skill.md diff --git a/tasks/recursive-language-model-skill-epic.md b/tasks/archive/2026-01-20-recursive-language-model-skill-epic.md similarity index 100% rename from tasks/recursive-language-model-skill-epic.md rename to tasks/archive/2026-01-20-recursive-language-model-skill-epic.md diff --git a/tasks/phase-1-sqlite-foundation.md b/tasks/phase-1-sqlite-foundation.md new file mode 100644 index 0000000..b0ab213 --- /dev/null +++ b/tasks/phase-1-sqlite-foundation.md @@ -0,0 +1,272 @@ +# Phase 1: SQLite Foundation + Indexing + Fan-out Search + +**Status**: 📋 PLANNED +**Goal**: Build core database infrastructure, indexing tools, and fan-out search capabilities that all subsequent phases depend on +**Dependencies**: None (foundational phase) + +## Epic Overview + +Establish the SQLite database foundation with schema for documents, dependencies, and productmanager data. Build indexing tools with TDD for frontmatter extraction and dependency graph construction. Implement fan-out search capabilities that combine keyword, semantic, and structured queries for rich result aggregation. + +This phase provides the data layer and search infrastructure that Jiron APIs, ProductManager skill, and RLM skill will build upon. + +--- + +## Create SQLite Schema + +Build complete database schema with JSON + FTS5 support. + +**Requirements**: +- Given database location, should create .aidd/index.db +- Given schema version tracking, should support migrations +- Given documents table, should store path, type, frontmatter JSON, content, hash +- Given FTS5 virtual table, should enable full-text search on content and frontmatter +- Given dependencies table, should track file import relationships +- Given productmanager tables, should support personas, journeys, steps, stories, pain points, functional requirements +- Given foreign keys, should enforce referential integrity +- Given indexes, should optimize common query patterns +- Given schema creation, should be idempotent (safe to re-run) + +**Success Criteria**: +- [ ] Schema creates all required tables +- [ ] FTS5 triggers sync with documents table +- [ ] Foreign keys validated +- [ ] Migrations system in place +- [ ] Tested with better-sqlite3 + +--- + +## Configure Git for SQLite + +Set up git to commit and diff SQLite databases. + +**Requirements**: +- Given .gitattributes, should mark *.db as binary +- Given git diff configuration, should use sqlite3 textconv +- Given .aidd/index.db, should be committed to repository +- Given git operations, should handle merges gracefully + +**Success Criteria**: +- [ ] .gitattributes configured for *.db files +- [ ] Git diff shows SQL output for database changes +- [ ] Database committed and pushable + +--- + +## Build Frontmatter Indexer + +Extract YAML frontmatter from all .md/.mdc files and store in SQLite. + +**Requirements**: +- Given markdown file with frontmatter, should parse YAML between --- delimiters +- Given frontmatter extraction, should store as JSON in database +- Given file content, should store without frontmatter +- Given file path, should determine type (rule, command, skill, task, story-map) +- Given file hash, should detect changes for incremental re-indexing +- Given batch processing, should use transactions for performance +- Given existing entry, should UPDATE instead of INSERT +- Given errors in YAML, should log and continue processing +- Given FTS5 sync, should populate full-text search automatically + +**Success Criteria**: +- [ ] Unit tests pass (vitest + riteway) +- [ ] Handles 100+ files in <1 second +- [ ] Incremental updates work correctly +- [ ] FTS5 search finds indexed content +- [ ] Error handling robust + +**Files**: +- ai/tools/index-frontmatter.js +- ai/tools/index-frontmatter.test.js + +--- + +## Build Dependency Indexer + +Parse file imports/requires and build dependency graph in SQLite. + +**Requirements**: +- Given JavaScript file, should extract import and require statements +- Given import statement, should resolve relative paths to absolute +- Given dependency found, should store from_file, to_file, import_type, line_number +- Given batch processing, should use transactions +- Given existing dependencies, should clear and rebuild for changed files +- Given import types, should distinguish 'import', 'require', 'reference' + +**Success Criteria**: +- [ ] Unit tests pass +- [ ] Correctly parses ES modules and CommonJS +- [ ] Graph traversal queries work +- [ ] Handles circular dependencies + +**Files**: +- ai/tools/index-dependencies.js +- ai/tools/index-dependencies.test.js + +--- + +## Implement Fan-out Search Core + +Build query orchestration that combines multiple search strategies. + +**Requirements**: +- Given search query, should determine appropriate strategies (keyword, semantic, structured) +- Given keyword search, should query SQLite FTS5 +- Given semantic search, should use built-in RAG capabilities +- Given structured query, should generate SQL for metadata filters +- Given multiple strategies, should execute in parallel +- Given results from multiple sources, should deduplicate by path +- Given result ranking, should combine scores from different sources +- Given result aggregation, should return unified JSON response +- Given max results limit, should apply after aggregation + +**Success Criteria**: +- [ ] Unit tests for each search strategy +- [ ] Parallel execution confirmed +- [ ] Deduplication works correctly +- [ ] Result ranking sensible +- [ ] Fast (<200ms for typical queries) + +**Files**: +- ai/tools/fan-out-search.js +- ai/tools/fan-out-search.test.js + +--- + +## Build Dependency Traversal Tool + +Implement recursive graph traversal for finding related files. + +**Requirements**: +- Given target file, should find all files that depend on it (reverse dependencies) +- Given target file, should find all files it depends on (forward dependencies) +- Given max depth parameter, should limit recursion +- Given traversal, should use recursive CTEs in SQLite +- Given results, should include depth level for each file +- Given circular dependencies, should handle gracefully +- Given path tracing, should show dependency chain + +**Success Criteria**: +- [ ] Unit tests with sample dependency graphs +- [ ] Recursive CTE works correctly +- [ ] Depth limiting functional +- [ ] Circular dependencies don't cause infinite loops +- [ ] Performance reasonable (depth 5 in <100ms) + +**Files**: +- ai/tools/find-related.js +- ai/tools/find-related.test.js + +--- + +## Create Query CLI Interface + +Build command-line interface for all query operations. + +**Requirements**: +- Given query string, should execute fan-out search +- Given --type filter, should limit to specific document types +- Given --format option, should output JSON or readable text +- Given --limit parameter, should constrain result count +- Given dependency query, should support forward/reverse/both directions +- Given metadata query, should support JSON path expressions +- Given help flag, should show usage examples +- Given errors, should provide helpful messages + +**Success Criteria**: +- [ ] CLI tests pass +- [ ] Help documentation clear +- [ ] JSON output valid +- [ ] Text output human-readable +- [ ] Error messages actionable + +**Files**: +- ai/tools/query.js (unified CLI) +- ai/tools/query.test.js + +--- + +## Create Indexing CLI Interface + +Build command-line tools to trigger indexing operations. + +**Requirements**: +- Given index-all command, should run frontmatter + dependencies indexers +- Given --watch flag, should re-index on file changes +- Given --incremental flag, should only process changed files +- Given --stats flag, should report indexing statistics +- Given errors, should log and continue +- Given completion, should report summary (files indexed, time taken) + +**Success Criteria**: +- [ ] CLI functional +- [ ] Watch mode works +- [ ] Incremental indexing faster than full +- [ ] Statistics accurate +- [ ] Pre-commit hook integration possible + +**Files**: +- ai/tools/index.js (unified indexing CLI) +- ai/tools/index.test.js + +--- + +## Add Bun Scripts to package.json + +Configure convenient npm/bun scripts for all tools. + +**Requirements**: +- Given package.json scripts, should include index, query, find-related +- Given script execution, should use bun for performance +- Given script naming, should be intuitive and consistent + +**Scripts**: +```json +{ + "aidd:index": "bun ai/tools/index.js", + "aidd:index:watch": "bun ai/tools/index.js --watch", + "aidd:query": "bun ai/tools/query.js", + "aidd:find-related": "bun ai/tools/find-related.js" +} +``` + +**Success Criteria**: +- [ ] All scripts work +- [ ] Documentation in README + +--- + +## Write Integration Tests + +Test full workflow from file creation to query. + +**Requirements**: +- Given new markdown file with frontmatter, should index and be queryable +- Given file modification, should re-index automatically +- Given file deletion, should remove from index +- Given fan-out search, should find results from multiple strategies +- Given dependency changes, should update graph correctly + +**Success Criteria**: +- [ ] Integration tests pass +- [ ] Cover real aidd files +- [ ] Test data fixtures included +- [ ] CI-friendly (fast, no external deps) + +**Files**: +- ai/tools/integration.test.js + +--- + +## Success Criteria (Phase 1) + +- [ ] SQLite database schema complete and committed to git +- [ ] Frontmatter indexer tested and functional +- [ ] Dependency indexer tested and functional +- [ ] Fan-out search combines multiple strategies effectively +- [ ] Dependency traversal handles complex graphs +- [ ] CLI tools intuitive and well-documented +- [ ] All unit tests pass (>90% coverage) +- [ ] Integration tests validate full workflow +- [ ] Performance meets targets (<1s indexing, <200ms queries) +- [ ] Ready for Jiron API layer (Phase 2) diff --git a/tasks/phase-2-jiron-db-api-skill.md b/tasks/phase-2-jiron-db-api-skill.md new file mode 100644 index 0000000..f6d7dcf --- /dev/null +++ b/tasks/phase-2-jiron-db-api-skill.md @@ -0,0 +1,373 @@ +# Phase 2: Jiron DB API Skill + +**Status**: 📋 PLANNED +**Goal**: Create a reusable agent skill that generates self-documenting Jiron APIs from SudoLang interface definitions and SQLite databases +**Dependencies**: Phase 1 (SQLite Foundation + Fan-out Search) + +## Epic Overview + +Build a generic skill that takes SudoLang interface definitions and automatically generates Jiron API endpoints with rich query capabilities. This skill will be the foundation for exposing both the frontmatter index (Phase 3) and productmanager data (Phase 4) as AI-friendly, self-documenting APIs. + +Jiron APIs provide progressive discovery, hypermedia affordances, and token-efficient responses ideal for AI agents. The skill should integrate with aidd's server middleware utilities and support the fan-out aggregated search capabilities built in Phase 1. + +--- + +## Research Jiron Protocol Patterns + +Study Jiron protocol and identify patterns for AI agent integration. + +**Requirements**: +- Given Jiron spec, should understand hypermedia affordances +- Given Jiron format (pug syntax), should understand rendering +- Given self-documentation requirements, should understand discovery pattern +- Given AI agent optimization, should understand token efficiency +- Given code-on-demand, should understand JavaScript delivery capability +- Given existing Jiron examples, should identify common patterns + +**Success Criteria**: +- [ ] Document Jiron core concepts in plan/jiron-skill/ +- [ ] Identify API endpoint patterns +- [ ] Understand progressive discovery model +- [ ] Document integration strategy with aidd middleware + +--- + +## Create Jiron Protocol Skill + +Build a foundational skill that teaches AI agents how to understand and use Jiron protocol. + +**Requirements**: +- Given SKILL.md format, should follow Agent Skills specification +- Given skill description, should explain Jiron as self-documenting API protocol for AI agents +- Given Jiron concepts, should explain hypermedia affordances +- Given pug syntax, should provide examples and patterns +- Given progressive discovery, should explain navigation through links +- Given code-on-demand, should explain JavaScript delivery +- Given token efficiency, should compare to JSON and explain benefits +- Given usage patterns, should show how to consume Jiron APIs +- Given AI agent consumption, should explain programmatic traversal +- Given examples, should include common entity/collection/action patterns + +**Skill Structure**: +``` +ai/skills/jiron/ +└── SKILL.md +``` + +**Success Criteria**: +- [ ] SKILL.md follows Agent Skills spec +- [ ] Explains Jiron core concepts clearly +- [ ] Provides concrete usage examples +- [ ] Shows how AI agents navigate Jiron APIs +- [ ] Agents can learn Jiron from skill alone +- [ ] Ready for agents to reference when using Jiron APIs + +**Files**: +- ai/skills/jiron/SKILL.md + +--- + +## Design SudoLang → Jiron Mapping + +Define how SudoLang interfaces map to Jiron API endpoints. + +**Requirements**: +- Given SudoLang interface definition, should map to Jiron entity structure +- Given SudoLang function definitions, should map to Jiron actions +- Given SudoLang constraints, should generate API validation +- Given nested interfaces, should create nested resource endpoints +- Given function parameters, should generate Jiron forms/fields +- Given return types, should define response structure + +**Example Mapping**: +```sudolang +// SudoLang Interface +Persona { + id: String + name: String + description: String + metadata: Object +} + +createPersona(name, description, metadata?): Persona + +// Maps to Jiron API: +// GET /api/personas - list with links to each persona +// GET /api/personas/:id - single persona entity +// POST /api/personas - form with name, description, metadata fields +// PUT /api/personas/:id - update form +// DELETE /api/personas/:id - delete action +``` + +**Success Criteria**: +- [ ] Mapping rules documented +- [ ] Examples for common patterns +- [ ] Validation rules clear +- [ ] Nested resource handling defined + +--- + +## Build SudoLang Interface Parser + +Parse SudoLang definitions and extract API structure. + +**Requirements**: +- Given SudoLang interface file, should parse interface definitions +- Given interface fields, should extract field names and types +- Given function definitions, should extract signatures +- Given constraints, should extract validation rules +- Given parse errors, should provide helpful messages +- Given parsed structure, should return JSON representation + +**Success Criteria**: +- [ ] Unit tests with various SudoLang patterns +- [ ] Handles interfaces, functions, constraints +- [ ] Error messages actionable +- [ ] JSON output well-structured + +**Files**: +- ai/skills/jiron-db-api/tools/parse-sudolang.js +- ai/skills/jiron-db-api/tools/parse-sudolang.test.js + +--- + +## Build Jiron Endpoint Generator + +Generate Jiron API endpoints from parsed SudoLang. + +**Requirements**: +- Given parsed interface, should generate entity endpoints (GET /resource/:id) +- Given collection, should generate list endpoints (GET /resources) +- Given create function, should generate POST endpoint with form +- Given update function, should generate PUT endpoint +- Given delete function, should generate DELETE endpoint +- Given nested resources, should generate hierarchical routes +- Given Jiron format, should use pug syntax +- Given hypermedia links, should include navigation affordances + +**Success Criteria**: +- [ ] Generates valid Jiron/pug markup +- [ ] Routes follow REST conventions +- [ ] Forms include all required fields +- [ ] Links enable progressive discovery +- [ ] Unit tests validate output + +**Files**: +- ai/skills/jiron-db-api/tools/generate-endpoints.js +- ai/skills/jiron-db-api/tools/generate-endpoints.test.js + +--- + +## Build SQLite Query Bridge + +Connect Jiron endpoints to SQLite database operations. + +**Requirements**: +- Given GET request, should query database by ID or filters +- Given POST request, should insert new record with validation +- Given PUT request, should update existing record +- Given DELETE request, should remove record +- Given foreign keys, should validate relationships +- Given transactions, should ensure atomicity +- Given query parameters, should support filtering, sorting, pagination +- Given JSON fields, should support JSON path queries +- Given errors, should return appropriate HTTP status codes + +**Success Criteria**: +- [ ] CRUD operations functional +- [ ] Foreign key validation works +- [ ] Transactions rollback on error +- [ ] Query parameters parsed correctly +- [ ] Unit tests with in-memory database + +**Files**: +- ai/skills/jiron-db-api/tools/db-bridge.js +- ai/skills/jiron-db-api/tools/db-bridge.test.js + +--- + +## Integrate Fan-out Search with Jiron + +Expose fan-out search capabilities via Jiron API endpoints. + +**Requirements**: +- Given search query parameter, should trigger fan-out search +- Given search results, should return as Jiron collection +- Given result ranking, should order by relevance score +- Given multiple search strategies, should aggregate results +- Given search filters, should combine with fan-out +- Given pagination, should limit and offset results +- Given search endpoint, should provide self-documenting form + +**Example Endpoint**: +``` +GET /api/search?q=authentication&type=rule&limit=20 +→ Fan out to: FTS5, semantic RAG, metadata filters +→ Returns: Jiron collection with ranked results +``` + +**Success Criteria**: +- [ ] Search endpoint functional +- [ ] Fan-out integration works +- [ ] Results properly formatted as Jiron +- [ ] Pagination works +- [ ] Performance acceptable (<500ms) + +**Files**: +- ai/skills/jiron-db-api/tools/search-endpoints.js +- ai/skills/jiron-db-api/tools/search-endpoints.test.js + +--- + +## Build Middleware Integration + +Integrate with aidd server middleware utilities. + +**Requirements**: +- Given aidd createRoute, should compose with Jiron handlers +- Given withRequestId, should include request tracking +- Given withCors, should enable cross-origin requests +- Given withServerError, should standardize error responses +- Given middleware chain, should use asyncPipe composition +- Given logging, should use aidd logger with scrubbing + +**Success Criteria**: +- [ ] Middleware composition works +- [ ] Request IDs tracked +- [ ] CORS headers set +- [ ] Errors formatted consistently +- [ ] Logging functional + +**Files**: +- ai/skills/jiron-db-api/tools/middleware.js +- ai/skills/jiron-db-api/tools/middleware.test.js + +--- + +## Create Jiron DB API Skill + +Write the complete skill specification with usage instructions. + +**Requirements**: +- Given SKILL.md format, should include proper frontmatter +- Given skill description, should explain when to use +- Given usage instructions, should document SudoLang → Jiron workflow +- Given examples, should show common patterns +- Given tool references, should link to generated endpoints +- Given constraints, should document limitations + +**Skill Structure**: +``` +ai/skills/jiron-db-api/ +├── SKILL.md +└── tools/ + ├── parse-sudolang.js + ├── generate-endpoints.js + ├── db-bridge.js + ├── search-endpoints.js + ├── middleware.js + └── *.test.js +``` + +**Success Criteria**: +- [ ] SKILL.md follows Agent Skills spec +- [ ] Instructions clear and actionable +- [ ] Examples demonstrate full workflow +- [ ] Constraints documented +- [ ] Ready for use by agents + +**Files**: +- ai/skills/jiron-db-api/SKILL.md + +--- + +## Build Code Generation CLI + +Create CLI tool to generate Jiron API from SudoLang. + +**Requirements**: +- Given SudoLang file path, should parse and generate endpoints +- Given database path, should connect and validate schema +- Given output directory, should write generated API files +- Given validation mode, should check without generating +- Given verbose flag, should show detailed progress +- Given errors, should provide actionable feedback + +**Usage**: +```bash +bun ai/skills/jiron-db-api/tools/generate.js \ + --schema path/to/schema.sudo \ + --db .aidd/index.db \ + --output src/api/ +``` + +**Success Criteria**: +- [ ] CLI functional +- [ ] Help documentation clear +- [ ] Generated code valid +- [ ] Error handling robust + +**Files**: +- ai/skills/jiron-db-api/tools/generate.js +- ai/skills/jiron-db-api/tools/generate.test.js + +--- + +## Write Comprehensive Tests + +Test full SudoLang → Jiron → SQLite workflow. + +**Requirements**: +- Given sample SudoLang schema, should generate working API +- Given API requests, should perform CRUD operations +- Given search requests, should return fan-out results +- Given validation, should reject invalid inputs +- Given foreign keys, should enforce relationships +- Given concurrent requests, should handle safely + +**Success Criteria**: +- [ ] Integration tests pass +- [ ] Sample schemas included +- [ ] API behavior validated +- [ ] Performance acceptable + +**Files**: +- ai/skills/jiron-db-api/tools/integration.test.js + +--- + +## Document Skill Usage + +Create comprehensive documentation and examples. + +**Requirements**: +- Given documentation, should explain SudoLang → Jiron workflow +- Given examples, should cover common patterns +- Given troubleshooting guide, should address common issues +- Given API reference, should document all generated endpoints +- Given middleware integration, should explain composition + +**Success Criteria**: +- [ ] Documentation clear and complete +- [ ] Examples runnable +- [ ] Troubleshooting helpful +- [ ] Ready for Phase 3 usage + +**Files**: +- plan/jiron-skill/usage-guide.md +- plan/jiron-skill/examples/ + +--- + +## Success Criteria (Phase 2) + +- [ ] Jiron DB API skill functional and tested +- [ ] SudoLang interfaces map to Jiron endpoints correctly +- [ ] SQLite integration works with all CRUD operations +- [ ] Fan-out search exposed via Jiron API +- [ ] Middleware integration with aidd server utilities +- [ ] Code generation CLI operational +- [ ] Comprehensive tests pass (unit + integration) +- [ ] Documentation complete with examples +- [ ] Skill ready for use in Phase 3 (frontmatter API) and Phase 4 (productmanager API) +- [ ] Reusable for future database-backed APIs diff --git a/tasks/phase-3-frontmatter-jiron-api.md b/tasks/phase-3-frontmatter-jiron-api.md new file mode 100644 index 0000000..621cbb3 --- /dev/null +++ b/tasks/phase-3-frontmatter-jiron-api.md @@ -0,0 +1,313 @@ +# Phase 3: Frontmatter Index Jiron API + +**Status**: 📋 PLANNED +**Goal**: Apply Jiron DB API skill to expose frontmatter index and codebase queries as self-documenting API with rich fan-out search +**Dependencies**: Phase 1 (SQLite Foundation), Phase 2 (Jiron DB API Skill) + +## Epic Overview + +Use the Jiron DB API skill to generate a comprehensive API for the frontmatter index. Expose documents, dependencies, and fan-out search capabilities through AI-friendly, self-documenting Jiron endpoints. Enable agents to discover and query codebase metadata programmatically with progressive discovery. + +This API will be the foundation for RLM skill's recursive exploration capabilities and general codebase understanding. + +--- + +## Define SudoLang Schema for Frontmatter Index + +Create SudoLang interface definitions for documents and dependencies. + +**Requirements**: +- Given documents table, should define Document interface +- Given frontmatter JSON, should define flexible metadata structure +- Given dependencies table, should define Dependency interface +- Given search capabilities, should define Search interface +- Given query parameters, should define filter interfaces +- Given relationships, should define document → dependencies links + +**SudoLang Schema**: +```sudolang +Document { + path: String(primary key) + type: "rule" | "command" | "skill" | "task" | "story-map" | "other" + frontmatter: Object + content: String + hash: String + indexedAt: Timestamp + fileSize: Number + modifiedAt: Timestamp +} + +Dependency { + fromFile: String + toFile: String + importType: "import" | "require" | "reference" | "link" + lineNumber: Number + importText: String +} + +SearchQuery { + q: String // Search query + type?: String // Filter by document type + limit?: Number = 20 // Result limit + offset?: Number = 0 // Pagination offset +} + +SearchResult { + document: Document + relevanceScore: Number + matchType: "keyword" | "semantic" | "metadata" + snippet: String +} + +DependencyQuery { + file: String // Target file + direction: "forward" | "reverse" | "both" + depth?: Number = 3 // Traversal depth +} + +// Functions +getDocument(path: String): Document +listDocuments(type?: String, limit?: Number): Document[] +searchDocuments(query: SearchQuery): SearchResult[] +getDependencies(query: DependencyQuery): Dependency[] +getRelatedFiles(path: String, depth?: Number): Document[] +``` + +**Success Criteria**: +- [ ] Schema complete and well-documented +- [ ] Covers all frontmatter index features +- [ ] Includes search and traversal operations +- [ ] Ready for Jiron generation + +**Files**: +- ai/schemas/frontmatter-index.sudo + +--- + +## Generate Jiron API from Schema + +Use Jiron DB API skill to generate endpoints from SudoLang schema. + +**Requirements**: +- Given SudoLang schema, should generate Jiron endpoints +- Given Document interface, should create /api/documents/* routes +- Given Dependency interface, should create /api/dependencies/* routes +- Given search operations, should create /api/search endpoint +- Given traversal operations, should create /api/traverse endpoint +- Given pug syntax, should generate valid Jiron markup +- Given hypermedia links, should enable progressive discovery + +**Generated Endpoints**: +``` +GET /api/documents - List all documents with filters +GET /api/documents/:path - Single document detail +GET /api/documents/:path/deps - Dependencies for document +GET /api/dependencies - List dependencies +GET /api/dependencies/graph - Full dependency graph +GET /api/search - Fan-out search +POST /api/search - Rich query with filters +GET /api/traverse/:path - Recursive dependency traversal +``` + +**Success Criteria**: +- [ ] All endpoints generated correctly +- [ ] Jiron format valid +- [ ] Links enable navigation +- [ ] Forms include proper fields + +**Files**: +- src/api/frontmatter/ (generated) + +--- + +## Implement Search Endpoint with Fan-out + +Connect search endpoint to Phase 1 fan-out search capabilities. + +**Requirements**: +- Given search query, should trigger fan-out across strategies +- Given keyword search, should query FTS5 +- Given semantic search, should use built-in RAG +- Given metadata filters, should query JSON fields +- Given parallel execution, should aggregate results +- Given relevance scoring, should rank unified results +- Given pagination, should support limit/offset +- Given Jiron response, should format as discoverable collection + +**Success Criteria**: +- [ ] Fan-out integration works +- [ ] All search strategies active +- [ ] Results properly ranked +- [ ] Pagination functional +- [ ] Response time <500ms + +--- + +## Implement Traversal Endpoint + +Expose dependency graph traversal via Jiron API. + +**Requirements**: +- Given target file path, should find related files +- Given direction parameter, should traverse forward/reverse/both +- Given depth parameter, should limit recursion +- Given traversal results, should include path traces +- Given Jiron response, should link to related documents +- Given circular dependencies, should handle gracefully + +**Success Criteria**: +- [ ] Traversal works in all directions +- [ ] Depth limiting functional +- [ ] Path traces included +- [ ] Jiron links navigate to documents + +--- + +## Add Frontmatter Metadata Queries + +Enable rich querying of frontmatter JSON fields. + +**Requirements**: +- Given JSON path query, should extract specific fields +- Given comparison operators, should filter by metadata values +- Given array fields, should support array operations +- Given nested objects, should support deep queries +- Given multiple conditions, should combine with AND/OR +- Given Jiron response, should highlight matched fields + +**Example Queries**: +``` +/api/documents?frontmatter.alwaysApply=true +/api/documents?frontmatter.tags[]=security +/api/documents?frontmatter.description~=authentication +``` + +**Success Criteria**: +- [ ] JSON path queries work +- [ ] Operators functional (=, !=, ~=, >, <) +- [ ] Array operations correct +- [ ] Complex queries supported + +--- + +## Integrate with aidd Server Middleware + +Wire up generated Jiron API with aidd middleware stack. + +**Requirements**: +- Given generated endpoints, should compose with createRoute +- Given requests, should include withRequestId +- Given CORS needs, should apply withCors +- Given errors, should use withServerError +- Given logging, should use aidd logger +- Given middleware chain, should use asyncPipe + +**Success Criteria**: +- [ ] Middleware composition works +- [ ] Request tracking functional +- [ ] CORS headers set +- [ ] Errors standardized +- [ ] Logging operational + +--- + +## Create API Server Entry Point + +Build server that hosts frontmatter Jiron API. + +**Requirements**: +- Given server start, should initialize database connection +- Given routes, should mount all Jiron endpoints +- Given port configuration, should use environment variable +- Given graceful shutdown, should close database +- Given health check, should expose /health endpoint +- Given documentation, should expose API explorer at root + +**Success Criteria**: +- [ ] Server starts successfully +- [ ] All routes accessible +- [ ] Configuration via env vars +- [ ] Graceful shutdown works +- [ ] Health check responds + +**Files**: +- src/api/frontmatter-server.js + +--- + +## Write API Documentation + +Document frontmatter Jiron API for users and agents. + +**Requirements**: +- Given API endpoints, should document all routes +- Given query parameters, should explain filters and options +- Given examples, should show common use cases +- Given Jiron navigation, should explain progressive discovery +- Given authentication (if needed), should document +- Given rate limits (if any), should document + +**Success Criteria**: +- [ ] Documentation complete +- [ ] Examples runnable +- [ ] Jiron concepts explained +- [ ] Ready for agent consumption + +**Files**: +- docs/api/frontmatter-index.md + +--- + +## Build Integration Tests + +Test full API workflow with real queries. + +**Requirements**: +- Given running API server, should respond to all endpoints +- Given search queries, should return relevant results +- Given traversal queries, should navigate dependencies correctly +- Given metadata queries, should filter accurately +- Given pagination, should handle large result sets +- Given concurrent requests, should handle safely +- Given error conditions, should return appropriate status codes + +**Success Criteria**: +- [ ] All endpoints tested +- [ ] Real aidd data tested +- [ ] Performance acceptable +- [ ] Error handling validated + +**Files**: +- src/api/frontmatter/integration.test.js + +--- + +## Add API to RLM Skill Documentation + +Document how RLM skill uses frontmatter API. + +**Requirements**: +- Given RLM exploration needs, should reference API endpoints +- Given examples, should show API usage in recursive queries +- Given fan-out search, should explain API integration +- Given progressive discovery, should demonstrate navigation + +**Success Criteria**: +- [ ] RLM documentation updated +- [ ] Examples clear +- [ ] Integration patterns documented + +--- + +## Success Criteria (Phase 3) + +- [ ] SudoLang schema complete for frontmatter index +- [ ] Jiron API generated and functional +- [ ] Search endpoint integrated with fan-out capabilities +- [ ] Traversal endpoint navigates dependency graph +- [ ] Metadata queries support rich filtering +- [ ] Middleware integration with aidd server utilities +- [ ] API server operational and documented +- [ ] Integration tests pass +- [ ] Ready for RLM skill consumption (Phase 5) +- [ ] Provides foundation for codebase exploration diff --git a/tasks/phase-4-productmanager-skill.md b/tasks/phase-4-productmanager-skill.md new file mode 100644 index 0000000..b1630f0 --- /dev/null +++ b/tasks/phase-4-productmanager-skill.md @@ -0,0 +1,413 @@ +# Phase 4: ProductManager Skill Conversion + +**Status**: 📋 PLANNED +**Goal**: Convert ai/rules/productmanager.mdc to a full Agent Skill with Jiron API backing and SQLite as source of truth +**Dependencies**: Phase 1 (SQLite Foundation), Phase 2 (Jiron DB API Skill) + +## Epic Overview + +Transform the existing productmanager.mdc rule into a complete Agent Skill with database-backed workflows. Use the Jiron DB API skill to expose story map data through self-documenting APIs. Migrate existing YAML data, provide export capabilities, and enable rich querying of personas, journeys, steps, and stories. + +The old ai/rules/productmanager.mdc will remain temporarily for validation until the new skill is proven equivalent or superior. + +--- + +## Analyze Existing ProductManager Implementation + +Study current productmanager.mdc to understand workflows and data patterns. + +**Requirements**: +- Given ai/rules/productmanager.mdc, should document all type definitions +- Given existing workflows, should identify key operations +- Given YAML structure, should map to database schema +- Given current usage, should identify what to preserve +- Given limitations, should identify improvements to make + +**Success Criteria**: +- [ ] Current capabilities documented +- [ ] Type definitions extracted +- [ ] Workflow patterns identified +- [ ] Migration plan created + +**Files**: +- plan/productmanager-conversion/analysis.md + +--- + +## Define SudoLang Schema for ProductManager + +Create comprehensive SudoLang interfaces for all productmanager entities. + +**Requirements**: +- Given productmanager types, should define SudoLang interfaces +- Given relationships, should define foreign key links +- Given computed fields, should define calculation logic +- Given CRUD operations, should define functions +- Given constraints, should define validation rules +- Given priority calculation, should define impact * frequency + +**SudoLang Schema**: +```sudolang +type id = String(cuid2) +type timestamp = Number(64-bit epoch) +type statusState = "backlog" | "inProgress" | "released" | "cancelled" + +Persona { + id: id(primary key) + name: String(required) + description: String + createdAt: timestamp + updatedAt: timestamp + metadata: Object +} + +PainPoint { + id: id(primary key) + name: String(required) + description: String + impact: Number(1..10, required) + frequency: Number(1..10, required) + createdAt: timestamp + updatedAt: timestamp + metadata: Object +} + +Journey { + id: id(primary key) + name: String(required) + description: String + personaIds: id[](foreign key -> Persona) + createdAt: timestamp + updatedAt: timestamp + metadata: Object +} + +Step { + id: id(primary key) + journeyId: id(foreign key -> Journey, required) + name: String(required) + description: String + orderIndex: Number(required) + createdAt: timestamp + updatedAt: timestamp + metadata: Object +} + +Story { + id: id(primary key) + stepId: id(foreign key -> Step, nullable) + painPointId: id(foreign key -> PainPoint, nullable) + name: String(required) + description: String // "As a X, I want Y, so that Z" + priority: Number(computed: painPoint.impact * painPoint.frequency) + status: statusState + createdAt: timestamp + updatedAt: timestamp + metadata: Object // mockups, etc. +} + +FunctionalRequirement { + id: id(primary key) + storyId: id(foreign key -> Story, required) + description: String(required) // "Given X, should Y" + orderIndex: Number(required) + createdAt: timestamp + metadata: Object +} + +// CRUD Functions +createPersona({ name, description, metadata }): Persona +updatePersona(id, updates): Persona +deletePersona(id): Boolean +getPersona(id): Persona +listPersonas(filters?): Persona[] + +createPainPoint({ name, description, impact, frequency, metadata }): PainPoint +updatePainPoint(id, updates): PainPoint +getPainPoint(id): PainPoint +listPainPoints(filters?): PainPoint[] + +createJourney({ name, description, personaIds, metadata }): Journey +updateJourney(id, updates): Journey +deleteJourney(id): Boolean +getJourney(id): Journey +listJourneys(personaId?): Journey[] + +createStep({ journeyId, name, description, orderIndex, metadata }): Step +updateStep(id, updates): Step +deleteStep(id): Boolean +getStep(id): Step +listSteps(journeyId): Step[] + +createStory({ name, description, painPointId, stepId, status, metadata }): Story +updateStory(id, updates): Story +deleteStory(id): Boolean +getStory(id): Story +listStories(filters?): Story[] +getHighPriorityStories(threshold, personaId?): Story[] + +createRequirement({ storyId, description, orderIndex, metadata }): FunctionalRequirement +updateRequirement(id, updates): FunctionalRequirement +deleteRequirement(id): Boolean +listRequirements(storyId): FunctionalRequirement[] + +// Complex Queries +getStoryMapSummary(): Object +findIncompleteJourneys(): Journey[] +getStoriesByPersona(personaId): Story[] +generatePRD(storyId): FeaturePRD +``` + +**Success Criteria**: +- [ ] All productmanager types covered +- [ ] Relationships defined correctly +- [ ] Functions match current workflows +- [ ] Ready for Jiron generation + +**Files**: +- ai/schemas/productmanager.sudo + +--- + +## Generate Jiron API from ProductManager Schema + +Use Jiron DB API skill to create productmanager API endpoints. + +**Requirements**: +- Given SudoLang schema, should generate Jiron endpoints +- Given all entities, should create CRUD routes +- Given relationships, should create nested resource routes +- Given complex queries, should create custom endpoints +- Given forms, should include validation +- Given hypermedia links, should enable navigation + +**Generated Endpoints**: +``` +GET /api/personas - List personas +POST /api/personas - Create persona +GET /api/personas/:id - Get persona +PUT /api/personas/:id - Update persona +DELETE /api/personas/:id - Delete persona + +GET /api/journeys - List journeys +POST /api/journeys - Create journey +GET /api/journeys/:id - Get journey +PUT /api/journeys/:id - Update journey +DELETE /api/journeys/:id - Delete journey +GET /api/journeys/:id/steps - Steps in journey + +GET /api/stories - List stories +POST /api/stories - Create story +GET /api/stories/:id - Get story +PUT /api/stories/:id - Update story +DELETE /api/stories/:id - Delete story +GET /api/stories/high-priority - High priority stories + +GET /api/story-maps/summary - Summary statistics +GET /api/story-maps/incomplete - Incomplete journeys +POST /api/story-maps/prd - Generate PRD from story +``` + +**Success Criteria**: +- [ ] All CRUD endpoints generated +- [ ] Nested routes functional +- [ ] Complex query endpoints included +- [ ] Jiron format valid + +**Files**: +- src/api/productmanager/ (generated) + +--- + +## Import Existing YAML Data + +Migrate existing story map YAML to SQLite database. + +**Requirements**: +- Given plan/story-map/*.yaml files, should parse all data +- Given YAML structure, should map to database schema +- Given existing IDs, should preserve them +- Given relationships, should link correctly +- Given migration errors, should report clearly +- Given duplicate data, should handle gracefully +- Given validation, should ensure data integrity + +**Success Criteria**: +- [ ] All existing YAML imported +- [ ] Relationships preserved +- [ ] IDs maintained +- [ ] Data validated +- [ ] No data loss + +**Files**: +- ai/skills/productmanager/tools/import-yaml.js +- ai/skills/productmanager/tools/import-yaml.test.js + +--- + +## Build YAML Export Tool + +Create tool to export database to YAML for human review. + +**Requirements**: +- Given database export, should generate YAML files +- Given file structure, should match original plan/story-map/ layout +- Given formatting, should be human-readable +- Given relationships, should use IDs consistently +- Given export path, should write to specified directory +- Given existing files, should prompt before overwriting + +**Success Criteria**: +- [ ] Export generates valid YAML +- [ ] Structure matches original +- [ ] Human-readable output +- [ ] Relationships clear + +**Files**: +- ai/skills/productmanager/tools/export-yaml.js +- ai/skills/productmanager/tools/export-yaml.test.js + +--- + +## Create ProductManager Skill + +Write comprehensive skill specification for AI agents. + +**Requirements**: +- Given SKILL.md format, should follow Agent Skills spec +- Given skill description, should explain product management workflows +- Given usage instructions, should document all operations +- Given database backing, should explain SQLite as source of truth +- Given YAML export, should document optional export +- Given API endpoints, should reference Jiron API +- Given examples, should show common workflows +- Given constraints, should document validation rules +- Given existing productmanager.mdc, should preserve key concepts + +**Skill Structure**: +``` +ai/skills/productmanager/ +├── SKILL.md +└── tools/ + ├── import-yaml.js + ├── export-yaml.js + └── *.test.js +``` + +**Success Criteria**: +- [ ] SKILL.md complete and clear +- [ ] All workflows documented +- [ ] Examples demonstrate usage +- [ ] Constraints explained +- [ ] Ready for agent use + +**Files**: +- ai/skills/productmanager/SKILL.md + +--- + +## Validate Against Original ProductManager + +Compare new skill behavior with original productmanager.mdc. + +**Requirements**: +- Given original workflows, should support equivalent operations +- Given original type definitions, should match database schema +- Given original constraints, should enforce same rules +- Given original outputs, should produce compatible results +- Given differences, should document improvements +- Given gaps, should address before deprecating original + +**Validation Tests**: +- Create persona → Same fields, same validation +- Create journey → Same workflow, better queries +- Create story → Same structure, computed priority +- Generate PRD → Same output format + +**Success Criteria**: +- [ ] All original workflows supported +- [ ] Type definitions compatible +- [ ] Constraints equivalent or better +- [ ] No regressions +- [ ] Improvements documented + +--- + +## Build Integration Tests + +Test full productmanager workflow with database and API. + +**Requirements**: +- Given API server, should support all CRUD operations +- Given relationships, should maintain foreign key integrity +- Given priority calculation, should compute correctly +- Given story map queries, should return accurate results +- Given concurrent operations, should handle safely +- Given validation, should reject invalid data + +**Success Criteria**: +- [ ] All CRUD operations tested +- [ ] Relationships validated +- [ ] Queries return correct results +- [ ] Validation works +- [ ] Performance acceptable + +**Files**: +- ai/skills/productmanager/integration.test.js + +--- + +## Document Migration Path + +Create guide for users to migrate from old to new productmanager. + +**Requirements**: +- Given migration guide, should explain benefits of new version +- Given steps, should provide clear migration instructions +- Given YAML data, should document import process +- Given validation, should explain how to verify migration +- Given deprecation timeline, should set expectations +- Given rollback, should explain how to revert if needed + +**Success Criteria**: +- [ ] Migration guide clear +- [ ] Steps actionable +- [ ] Verification process defined +- [ ] Timeline communicated + +**Files**: +- docs/productmanager-migration.md + +--- + +## Update AGENTS.md + +Add guidelines for using productmanager skill. + +**Requirements**: +- Given AGENTS.md, should add productmanager skill usage +- Given workflows, should explain when to use skill +- Given database backing, should explain SQLite source of truth +- Given API access, should reference Jiron endpoints +- Given examples, should show common patterns + +**Success Criteria**: +- [ ] AGENTS.md updated +- [ ] Usage guidelines clear +- [ ] Examples helpful + +--- + +## Success Criteria (Phase 4) + +- [ ] SudoLang schema complete for productmanager +- [ ] Jiron API generated and functional +- [ ] Existing YAML data imported successfully +- [ ] YAML export tool operational +- [ ] ProductManager skill complete and documented +- [ ] Validated against original productmanager.mdc +- [ ] Integration tests pass +- [ ] Migration guide published +- [ ] AGENTS.md updated +- [ ] Ready for production use +- [ ] Original productmanager.mdc can be deprecated after validation period diff --git a/tasks/phase-5-rlm-skill.md b/tasks/phase-5-rlm-skill.md new file mode 100644 index 0000000..8d1cb27 --- /dev/null +++ b/tasks/phase-5-rlm-skill.md @@ -0,0 +1,582 @@ +# Phase 5: Recursive Language Model Skill + +**Status**: 📋 PLANNED +**Goal**: Create RLM agent skill that enables deep codebase exploration through recursive task decomposition and hierarchical queries +**Dependencies**: Phase 1 (SQLite Foundation), Phase 2 (Jiron Skills), Phase 3 (Frontmatter API), Phase 4 (ProductManager Skill) + +## Epic Overview + +Build the Recursive Language Model (RLM) skill that brings together all previous phases into a coherent recursive exploration capability. This skill enables AI agents to handle complex queries about large codebases by recursively decomposing tasks, fanning out searches, and aggregating results—extending effective context far beyond model window limits. + +The RLM skill uses the MIT paper's strategies adapted for AI agent workflows, treating the codebase as an external environment to be programmatically explored through the Jiron APIs and query tools built in previous phases. + +--- + +## Design User Journey for RLM Skill + +Create comprehensive user journey following productmanager.mdc patterns. + +**Requirements**: +- Given persona of developer using AI agent on complex project, should define pain points +- Given pain points around context limits and incomplete understanding, should quantify impact and frequency +- Given user goal of comprehensive repository understanding, should map journey steps +- Given steps, should identify where RLM strategies provide value +- Given journey map, should save to database using productmanager API +- Given productmanager schema, should follow established patterns + +**User Story**: +"As a developer using an AI agent, I want my agent to have detailed command of my entire project repository, so that it can deliver contextually-aware results without missing critical dependencies or relationships." + +**Pain Points**: +- Agent misses relevant files when answering questions (impact: 8, frequency: 9) +- Agent can't trace complex dependencies across modules (impact: 9, frequency: 7) +- Agent gives incomplete answers for architectural questions (impact: 10, frequency: 6) +- Agent struggles with codebases >100 files (impact: 9, frequency: 8) + +**Success Criteria**: +- [ ] User journey documented and stored in database +- [ ] Pain points quantified +- [ ] Steps mapped to RLM capabilities +- [ ] Priority scores calculated + +--- + +## Define Recursive Decomposition Strategy + +Document how RLM breaks down complex queries hierarchically. + +**Requirements**: +- Given complex query, should define decomposition patterns +- Given query types, should categorize (architectural, dependency, pattern-finding, flow-tracing) +- Given decomposition depth, should define recursion limits +- Given sub-queries, should define aggregation strategies +- Given termination conditions, should prevent infinite recursion +- Given examples, should illustrate common patterns + +**Decomposition Patterns**: + +```sudolang +// Pattern 1: Architectural Understanding +Query: "How does authentication work in this project?" + +Decompose: +1. "Find all files related to authentication" + → FTS5 search for "auth", "login", "session" + → Metadata query for frontmatter tags +2. For each auth file: + → "What are the dependencies of this file?" + → Traverse dependency graph +3. For each dependency: + → "What is the purpose of this module?" (recursive) + → Extract frontmatter description or summarize +4. Aggregate: + → Synthesize auth flow from all findings + → Create architectural diagram (text) + +// Pattern 2: Dependency Tracing +Query: "What would break if I change module X?" + +Decompose: +1. "Find all files that import module X" + → Reverse dependency query +2. For each dependent: + → "Find files that import this dependent" (recursive to depth 3) + → Build impact tree +3. For each impacted file: + → "What functionality does this provide?" + → Extract from frontmatter or code comments +4. Aggregate: + → List of potentially affected features + → Impact radius report + +// Pattern 3: Pattern Finding +Query: "Find all implementations of the repository pattern" + +Decompose: +1. "Search for files containing 'repository'" + → FTS5 keyword search +2. For each candidate: + → "Does this match the repository pattern?" (semantic) + → Code structure analysis +3. For matches: + → "What entities does this repository manage?" (recursive) + → Extract interfaces or type definitions +4. Aggregate: + → List of all repository implementations + → Entities they manage + → Common patterns and deviations +``` + +**Success Criteria**: +- [ ] Decomposition patterns documented +- [ ] Examples cover common query types +- [ ] Recursion limits defined +- [ ] Aggregation strategies clear + +**Files**: +- plan/rlm/decomposition-patterns.md + +--- + +## Create RLM Skill Specification + +Write complete skill in SudoLang with recursive exploration functions. + +**Requirements**: +- Given SKILL.md format, should follow Agent Skills specification +- Given skill description, should explain when to use RLM +- Given recursive strategy, should define exploration functions +- Given available tools, should document Jiron APIs and CLI tools +- Given decomposition patterns, should include in skill instructions +- Given constraints, should define recursion limits and termination +- Given examples, should demonstrate full recursive workflows +- Given always-surfaced activation, should set alwaysApply: true + +**Skill Structure**: +``` +ai/skills/rlm/ +└── SKILL.md +``` + +**SKILL.md Content**: +```markdown +--- +name: rlm +description: Use when needing deep project context through recursive codebase exploration. Enables hierarchical task decomposition to handle queries beyond context window limits. +alwaysApply: true +--- + +# Recursive Language Model (RLM) Skill + +## When to Use + +Use this skill when: +- Query requires understanding across multiple files or modules +- Need to trace complex dependencies or data flows +- Building architectural understanding of systems +- Finding all instances of a pattern across codebase +- Context window insufficient for complete understanding + +Don't use when: +- Query targets single file or small scope +- Simple keyword search sufficient +- Already have relevant context loaded + +## Recursive Exploration Strategy + +fn exploreCodebase(query, depth = 0, maxDepth = 3) { + Constraints { + Stop if depth >= maxDepth + Stop if query is simple (single-file scope) + Stop if diminishing returns (new findings < threshold) + } + + // 1. Assess query complexity + if (isSimpleQuery(query)) { + return directSearch(query) + } + + // 2. Decompose into sub-queries + subQueries = decomposeQuery(query) // Use patterns from plan/rlm/decomposition-patterns.md + + // 3. Fan out parallel searches + results = [] + for each (subQuery in subQueries) { + parallel { + // Keyword search via Jiron API + keywordResults = GET /api/search?q=$subQuery + + // Semantic search (built-in RAG) + semanticResults = semanticSearch(subQuery) + + // Metadata filtering via Jiron API + metadataResults = GET /api/documents?frontmatter.tags[]=$tags + + // Dependency traversal if needed + if (requiresTraversal(subQuery)) { + depResults = GET /api/traverse/:path?depth=$depth + } + + // Recursive exploration for complex sub-queries + if (requiresDeeperContext(subQuery) && depth < maxDepth) { + deepResults = exploreCodebase(subQuery, depth + 1) + } + } + + results.append(aggregateResults(keywordResults, semanticResults, metadataResults, depResults, deepResults)) + } + + // 4. Synthesize findings + return synthesize(results, originalQuery) +} + +## Available Tools + +### Jiron APIs (Phase 3) +- GET /api/search - Fan-out search across FTS5, semantic, metadata +- GET /api/documents/:path - Get document with frontmatter +- GET /api/documents/:path/deps - Dependencies for document +- GET /api/traverse/:path - Recursive dependency traversal +- GET /api/dependencies/graph - Full dependency graph + +### ProductManager API (Phase 4) +- GET /api/story-maps/summary - Project overview +- GET /api/journeys - User journeys and features +- GET /api/stories/high-priority - Important work items + +### CLI Tools (Phase 1) +- bun ai/tools/query.js "$query" - Direct database queries +- bun ai/tools/find-related.js $path - Dependency traversal + +### Built-in Agent Capabilities +- Grep - Pattern matching +- Glob - File discovery +- Read - File content examination +- RAG - Semantic search (already available) + +## Query Decomposition Patterns + +[Include patterns from decomposition-patterns.md] + +## Example: Understanding Authentication Flow + +Query: "Explain how authentication works in this project" + +Step 1: Decompose +- "Find auth-related files" +- "Trace login dependencies" +- "Find session management" +- "Identify security rules" + +Step 2: Fan out searches +parallel { + GET /api/search?q=authentication&type=rule + GET /api/search?q=login + GET /api/documents?frontmatter.tags[]=security + semanticSearch("authentication flow") +} + +Step 3: Recursive exploration +For each auth file found: + GET /api/documents/$path + GET /api/traverse/$path?depth=2 + If complex: exploreCodebase("purpose of $dependency", depth+1) + +Step 4: Synthesize +Aggregate: +- Auth entry points (login routes) +- Session management (cookies, tokens) +- Security rules (validation, CSRF) +- Dependency chain (auth → session → db) + +Return: Comprehensive auth flow explanation + +## Performance Considerations + +### Recursion Limits +- Default maxDepth: 3 +- Configurable via query parameter +- Prevent exponential explosion + +### Caching +- SQLite acts as metadata cache +- Avoid re-fetching same files +- Reuse dependency graph results + +### Parallel Execution +- Fan out independent searches +- Aggregate results efficiently +- Limit concurrent API calls + +### Cost Management +- More API calls = higher cost +- But better quality for complex queries +- Agent decides trade-off based on query importance + +## Integration with Other Skills + +### With ProductManager +Use productmanager API to understand project structure: +GET /api/journeys → Learn what features exist +GET /api/stories → Understand user requirements +Context informs codebase exploration + +### With Jiron Protocol +All APIs follow Jiron self-documenting format +Progressive discovery through hypermedia links +Navigate relationships without prior API knowledge + +## Guidelines for Agents + +1. **Assess before recursing**: Is this query truly complex? +2. **Decompose thoughtfully**: Break into logical, independent sub-queries +3. **Fan out aggressively**: Parallel searches are fast +4. **Recurse judiciously**: Only when sub-query needs deeper context +5. **Synthesize clearly**: User wants coherent answer, not raw data +6. **Monitor depth**: Respect maxDepth to prevent runaway recursion +7. **Cache results**: Don't re-query same data +8. **Explain reasoning**: Show decomposition strategy in response + +## Success Metrics + +RLM is working well when: +- Complex queries get comprehensive answers +- Agents find relevant files they would have missed +- Dependency traces are complete and accurate +- Large codebases (>100 files) handled smoothly +- Recursion terminates appropriately +- Response quality > cost of extra API calls +``` + +**Success Criteria**: +- [ ] SKILL.md complete and comprehensive +- [ ] Follows Agent Skills spec +- [ ] Recursive strategy well-defined +- [ ] Examples demonstrate capability +- [ ] Integration with Jiron APIs clear +- [ ] Guidelines help agents use effectively + +**Files**: +- ai/skills/rlm/SKILL.md + +--- + +## Update AGENTS.md with RLM Guidelines + +Add RLM usage rules to agent guidelines. + +**Requirements**: +- Given AGENTS.md, should add section on project context exploration +- Given RLM skill activation, should explain when to use +- Given alwaysApply: true, should note skill is always loaded +- Given agent decision-making, should explain how to choose RLM +- Given examples, should show before/after scenarios +- Given performance, should note trade-offs + +**AGENTS.md Addition**: +```markdown +## Project Context Exploration with RLM + +When you need comprehensive understanding of complex project areas: + +### When to Activate RLM + +The RLM (Recursive Language Model) skill is always loaded but you decide when to invoke it: + +**Use RLM when**: +- Query spans multiple files or modules +- Need to trace dependencies or data flows +- Building architectural understanding +- Finding patterns across entire codebase +- Simple searches return incomplete results + +**Don't use RLM when**: +- Query targets single file +- Answer in current context +- Simple keyword search sufficient + +### How RLM Works + +1. **Decompose**: Break complex query into sub-queries +2. **Fan out**: Search in parallel (keyword + semantic + metadata) +3. **Traverse**: Follow dependency graphs recursively +4. **Aggregate**: Synthesize findings into coherent answer + +### Example Usage + +**Before RLM** (incomplete answer): +User: "How does authentication work?" +Agent: *Searches "auth", finds login.js, reads it* +Response: "Login uses JWT tokens..." (misses session mgmt, CSRF, validation) + +**With RLM** (comprehensive): +User: "How does authentication work?" +Agent: *Activates RLM skill* +1. Decomposes: [find auth files, trace deps, find security rules] +2. Fans out: API search + semantic + metadata queries +3. Traverses: Dependencies of each auth file +4. Synthesizes: Complete auth flow with all components +Response: "Authentication system has 3 layers: + 1. Login (login.js, session.js) + 2. Validation (auth-middleware.js, csrf.js) + 3. Session (cookie-handler.js, token-manager.js) + Flow: User submits credentials → validates → creates session → sets cookie..." + +### Available Tools + +The RLM skill uses these tools: +- Jiron APIs (self-documenting, progressive discovery) +- SQLite queries (structured metadata) +- Dependency traversal (graph exploration) +- Built-in RAG (semantic search) +- Standard tools (Grep, Read, Glob) + +### Performance Notes + +- RLM makes more API calls (higher cost) +- But delivers better quality for complex queries +- You decide the trade-off based on query importance +- Recursion depth limited to prevent runaway costs +``` + +**Success Criteria**: +- [ ] AGENTS.md updated with clear guidelines +- [ ] Examples demonstrate value +- [ ] When to use / not use clear +- [ ] Integration with tools explained + +--- + +## Test RLM with Real Queries + +Validate RLM skill with actual aidd codebase queries. + +**Requirements**: +- Given aidd codebase, should execute real complex queries +- Given test queries, should demonstrate recursive decomposition +- Given results, should validate comprehensiveness +- Given comparison, should show improvement over simple search +- Given performance, should measure API calls and time +- Given edge cases, should handle gracefully + +**Test Queries**: + +1. **Architectural**: "How does the task epic system work?" + - Should find: task files, productmanager integration, YAML structure + - Should trace: Dependencies between task creator and rules + - Should synthesize: Complete workflow explanation + +2. **Dependency**: "What would break if we change please.mdc?" + - Should find: All files referencing please.mdc + - Should traverse: Reverse dependencies + - Should report: Impact radius + +3. **Pattern**: "Find all SudoLang interface definitions" + - Should search: FTS5 for interface patterns + - Should identify: All .mdc files with interfaces + - Should extract: Interface structures + +4. **Flow**: "How do commands work end-to-end?" + - Should trace: /command → ai/commands/*.md → ai/rules/*.mdc + - Should explore: Command invocation flow + - Should explain: Complete lifecycle + +**Success Criteria**: +- [ ] All test queries answered comprehensively +- [ ] Recursive decomposition logical +- [ ] Results include all relevant files +- [ ] Synthesis coherent and accurate +- [ ] Performance acceptable + +--- + +## Document RLM Skill Usage + +Create comprehensive usage guide and examples. + +**Requirements**: +- Given documentation, should explain RLM concepts clearly +- Given MIT paper findings, should relate to aidd implementation +- Given examples, should cover diverse query types +- Given troubleshooting, should address common issues +- Given best practices, should guide effective usage +- Given limitations, should be honest about constraints + +**Success Criteria**: +- [ ] Documentation complete +- [ ] Examples cover common scenarios +- [ ] Troubleshooting helpful +- [ ] Best practices actionable + +**Files**: +- docs/rlm-skill-guide.md + +--- + +## Create RLM Demonstration + +Build interactive demo showing RLM capabilities. + +**Requirements**: +- Given demonstration, should use real aidd codebase +- Given complex query, should show decomposition steps visually +- Given API calls, should log and display +- Given recursion, should show depth levels +- Given aggregation, should show how results combine +- Given final answer, should compare to non-RLM approach + +**Success Criteria**: +- [ ] Demo functional and impressive +- [ ] Clearly shows RLM value +- [ ] Can be shared with stakeholders +- [ ] Documents real-world effectiveness + +**Files**: +- demos/rlm-exploration.md (transcript) + +--- + +## Performance Optimization + +Tune RLM for optimal performance and cost. + +**Requirements**: +- Given API call patterns, should identify optimization opportunities +- Given caching, should avoid redundant queries +- Given parallelization, should maximize throughput +- Given recursion depth, should tune defaults +- Given termination conditions, should prevent unnecessary work +- Given cost monitoring, should track API usage + +**Optimizations**: +- Cache API responses during single query session +- Deduplicate file fetches across sub-queries +- Limit fanout breadth based on result quality +- Early termination when confidence threshold met +- Adaptive depth based on query complexity + +**Success Criteria**: +- [ ] Performance metrics documented +- [ ] Optimizations implemented +- [ ] Cost reasonable for value provided +- [ ] Monitoring in place + +--- + +## Integration Testing + +Test full RLM workflow across all phases. + +**Requirements**: +- Given SQLite database (Phase 1), should query effectively +- Given Jiron APIs (Phase 2-4), should consume correctly +- Given recursive decomposition, should work end-to-end +- Given fan-out search, should aggregate properly +- Given real codebase, should handle scale +- Given edge cases, should gracefully degrade + +**Success Criteria**: +- [ ] Integration tests comprehensive +- [ ] All phases work together +- [ ] Real codebase tested +- [ ] Performance validated + +**Files**: +- ai/skills/rlm/integration.test.js + +--- + +## Success Criteria (Phase 5) + +- [ ] User journey documented with pain points and priorities +- [ ] Recursive decomposition strategy defined and documented +- [ ] RLM skill complete with comprehensive SKILL.md +- [ ] AGENTS.md updated with clear usage guidelines +- [ ] Real query testing validates effectiveness +- [ ] Usage documentation comprehensive +- [ ] Demonstration showcases capabilities +- [ ] Performance optimized for cost/quality trade-off +- [ ] Integration testing confirms all phases work together +- [ ] RLM skill ready for production use +- [ ] Agents can effectively explore complex codebases beyond context limits +- [ ] Delivers significant value over simple search approaches From 9a8adf4fcdcb63e0e1c029cf15299a9a9b08ce97 Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 20 Jan 2026 14:32:52 +0000 Subject: [PATCH 4/7] Add review of janhesters' Claude Code skills branch Analyzed 2026-01-20-claude-code-skills branch to check for conflicts with our Phase 1-5 RLM + DB + Jiron epic plans. Key findings: - No blocking conflicts (.claude/ vs ai/ directories) - janhesters built YAML-based skills for Claude Code - Our approach adds SQLite + Jiron APIs + RLM on top - Different problem spaces that complement each other - Both can coexist and potentially converge later Recommendation: Proceed with all 5 phases as planned. --- plan/rlm/review-janhesters-branch.md | 353 +++++++++++++++++++++++++++ 1 file changed, 353 insertions(+) create mode 100644 plan/rlm/review-janhesters-branch.md diff --git a/plan/rlm/review-janhesters-branch.md b/plan/rlm/review-janhesters-branch.md new file mode 100644 index 0000000..6763909 --- /dev/null +++ b/plan/rlm/review-janhesters-branch.md @@ -0,0 +1,353 @@ +# Review: janhesters' Claude Code Skills Branch + +**Branch**: `2026-01-20-claude-code-skills` +**Commit**: b16610b "feat(skills): add Claude Code skills integration" +**Reviewer**: Claude (analyzing for compatibility with Phase 1-5 epics) + +--- + +## What janhesters Built + +### Structure Created + +**New `.claude/` directory** for Claude Code-specific integration: +``` +.claude/ +├── CLAUDE.md # Project-wide AIDD principles +├── settings.local.json # Claude Code settings +├── commands/ # Slash commands +│ ├── commit.md +│ ├── discover.md +│ ├── execute.md +│ ├── init.md +│ ├── log.md +│ ├── review.md +│ ├── task.md +│ └── user-test.md +└── skills/ # Agent Skills + ├── aidd-commit/ + ├── aidd-discover/ + ├── aidd-execute/ + ├── aidd-init/ + ├── aidd-log/ + ├── aidd-review/ + ├── aidd-task/ + └── aidd-user-test/ +``` + +### Key Characteristics + +**1. Claude Code Specific** +- Uses `.claude/` directory (Claude Code convention) +- Does NOT create `ai/skills/` directory +- Leaves `ai/rules/` and `ai/commands/` untouched +- Additive, not replacement + +**2. Skills Follow Agent Skills Spec** +- Proper frontmatter (name, description, allowed-tools) +- SKILL.md format +- Reference files for progressive discovery +- Examples: aidd-discover, aidd-task, aidd-execute, etc. + +**3. ProductManager → aidd-discover** +- Mirrors `ai/rules/productmanager.mdc` functionality +- Formatted as Agent Skill +- Still uses **YAML storage** in `plan/story-map/` +- No database backing +- Reference file: `.claude/skills/aidd-discover/references/types.md` + +**4. Commands Mirror ai/commands** +- `/discover` → uses aidd-discover skill +- `/task` → uses aidd-task skill +- `/commit` → uses aidd-commit skill +- etc. + +--- + +## Compatibility Analysis + +### ✅ Compatible Elements + +**1. Directory Structure** +- `.claude/` is separate from our planned `ai/skills/` +- No conflicts - both can coexist +- Our phases focus on `ai/skills/` for framework-agnostic skills +- His `.claude/skills/` are Claude Code-specific + +**2. Conceptual Alignment** +- Both use Agent Skills specification +- Both follow SKILL.md format +- Both include reference files for context +- Both recognize need for skills over rules + +**3. Workflow Preservation** +- His work preserves existing `ai/rules/productmanager.mdc` +- Our Phase 4 keeps old productmanager.mdc during transition +- Both approaches maintain backward compatibility + +### ⚠️ Incompatible Elements + +**1. Storage Strategy - MAJOR DIFFERENCE** +``` +janhesters approach: + YAML in plan/story-map/ = source of truth + No database + Skills read/write YAML directly + +Our Phase 1-4 approach: + SQLite .aidd/index.db = source of truth (committed to git) + YAML export on demand + Skills use database + Jiron APIs +``` + +**Impact**: These are fundamentally different architectures +- Can coexist but serve different purposes +- His: Simple YAML-based workflow +- Ours: Rich querying, relationships, Jiron APIs + +**2. API Layer** +``` +janhesters approach: + No API layer + Direct file manipulation + Skills interact with YAML + +Our Phase 2-3 approach: + Jiron APIs expose data + SQLite backend + Self-documenting, progressive discovery + Agent Skills consume APIs +``` + +**Impact**: His skills are simpler but less queryable +- Our approach enables fan-out search, complex queries +- His approach is lighter weight, faster to ship + +**3. Skill Scope** +``` +janhesters approach: + aidd-discover = productmanager functionality + Focused on YAML workflows + No recursive exploration + +Our Phase 4-5 approach: + productmanager skill = database-backed story maps + RLM skill = recursive codebase exploration + Uses Jiron APIs for rich queries +``` + +**Impact**: Different problem spaces +- His: Replicate existing YAML workflows in Claude Code +- Ours: Enable database-backed workflows + recursive exploration + +--- + +## Missed Opportunities (Based on Our Context) + +### 1. **Database Backing for Story Maps** + +**What's Missing**: +- aidd-discover still uses YAML as source of truth +- No SQLite integration +- No rich querying capabilities +- Can't do: "Show all high-priority stories for persona X" + +**Our Approach Advantage**: +- SQLite enables complex queries across personas, journeys, stories +- Foreign keys ensure data integrity +- Aggregations (AVG priority, COUNT stories by status) +- Better for large story maps + +**Why It Matters**: +- YAML works for small projects +- Doesn't scale to complex products with 100+ stories +- Can't power dashboard or analytics + +### 2. **Jiron API Layer** + +**What's Missing**: +- No self-documenting API for story map data +- No progressive discovery +- Skills can't query data, only read/write YAML files +- No fan-out search across story maps + +**Our Approach Advantage**: +- Jiron APIs enable AI agents to discover capabilities +- Hypermedia links guide navigation +- Can query: "Find stories related to authentication" +- Token-efficient for AI consumption + +**Why It Matters**: +- Agents can explore story maps programmatically +- Enables integration with other tools +- Foundation for richer agent capabilities + +### 3. **Fan-out Search Integration** + +**What's Missing**: +- No integration with frontmatter indexing +- No way to search across codebase + story maps +- Can't answer: "What code implements this user story?" + +**Our Approach Advantage**: +- Phase 3 frontmatter API connects code to requirements +- Can trace: story → code files → dependencies +- RLM skill uses fan-out to explore relationships + +**Why It Matters**: +- Bridges gap between product artifacts and code +- Enables impact analysis +- Better for understanding system holistically + +### 4. **Recursive Exploration (RLM)** + +**What's Missing**: +- No skill for deep codebase exploration +- No recursive decomposition strategy +- Limited to simple YAML read/write operations + +**Our Approach Advantage**: +- Phase 5 RLM skill handles complex queries +- Recursively explores beyond context limits +- Uses all previous phases (SQLite + Jiron + fan-out) + +**Why It Matters**: +- Essential for large codebases (>100 files) +- Enables architectural understanding +- Core differentiator for aidd framework + +### 5. **Skill Reusability** + +**What's Missing**: +- Skills are Claude Code-specific (.claude/ directory) +- Not usable by Cursor, VS Code Copilot, or other Agent Skills tools +- Tied to YAML storage format + +**Our Approach Advantage**: +- ai/skills/ is framework-agnostic +- Agent Skills spec works across tools +- Database backing enables any client + +**Why It Matters**: +- Skills should work in any compatible tool +- AIDD framework should be tool-agnostic +- Maximizes skill investment ROI + +--- + +## Recommendations + +### Short Term: Both Approaches Complement Each Other + +**Keep janhesters' work for:** +- Quick Claude Code integration (already done!) +- YAML-based workflows (simple projects) +- Users who want lightweight setup + +**Proceed with our Phase 1-5 for:** +- Database-backed productmanager (Phase 4) +- Jiron API layer (Phase 2-3) +- RLM recursive exploration (Phase 5) +- Complex querying and analytics + +**They serve different needs**: +``` +.claude/skills/ → Claude Code users, YAML workflows +ai/skills/ → Framework-agnostic, database workflows +``` + +### Medium Term: Convergence Opportunities + +**Option 1: Enhance .claude/skills with Database** +- Update aidd-discover to optionally use SQLite +- Keep YAML as export format +- Add Jiron API consumption to Claude Code skills + +**Option 2: Create ai/skills and Reference from .claude** +- Build ai/skills/ as planned (framework-agnostic) +- Have .claude/skills/ reference ai/skills/ for shared logic +- .claude/ becomes thin wrapper + +**Option 3: Parallel Evolution** +- Let both approaches mature independently +- .claude/ stays simple and YAML-based +- ai/ becomes advanced database + API layer +- Users choose based on needs + +### Long Term: Unified Architecture + +**Ideal State**: +``` +ai/skills/productmanager/ # Database-backed, Jiron API + ├── SKILL.md # Framework-agnostic skill + ├── tools/ + │ ├── db-adapter.js # SQLite interface + │ ├── export-yaml.js # Optional YAML export + │ └── import-yaml.js # Migrate from YAML + +.claude/skills/aidd-discover/ # Claude Code wrapper + └── SKILL.md # References ai/skills/productmanager + # Adds Claude Code-specific guidance +``` + +**Benefits**: +- Single implementation (ai/skills) +- Claude Code gets enhancements automatically +- YAML export for those who need it +- Database power for those who want it + +--- + +## Action Items + +### 1. **Proceed with Phase 1-5 as Planned** ✅ +No blocking conflicts with janhesters' work +- Build ai/skills/ directory structure +- Implement database layer +- Create Jiron APIs +- RLM skill on top + +### 2. **Document Relationship** +Add to Phase 4 epic: +- Note: .claude/skills/aidd-discover exists for Claude Code +- Our ai/skills/productmanager is framework-agnostic +- Both can coexist serving different audiences + +### 3. **Consider Migration Path** +In Phase 4, provide tool to: +- Import from YAML (janhesters' format + legacy) +- Export to YAML (for .claude/skills compatibility) +- Allow users to transition gradually + +### 4. **Collaboration Opportunity** +Suggest to janhesters: +- ai/skills/ could power .claude/skills/ under the hood +- .claude/ becomes presentation layer +- Shared database backend +- But defer this conversation until Phase 4 complete + +--- + +## Conclusion + +### No Breaking Conflicts ✅ +- janhesters worked in `.claude/` directory +- We're working in `ai/` directory +- Both can coexist peacefully + +### Different Problem Spaces +- **His**: Claude Code integration with YAML workflows (done!) +- **Ours**: Database + Jiron + RLM for advanced capabilities (in progress) + +### Missed Opportunities (Worth Building) +1. ✅ Database backing for rich queries +2. ✅ Jiron API layer for self-documentation +3. ✅ Fan-out search integration +4. ✅ RLM recursive exploration +5. ✅ Framework-agnostic skills (ai/skills) + +### Recommendation: **Proceed with All 5 Phases** + +janhesters' work validates the Agent Skills approach and proves demand for productmanager as a skill. Our phases build the database + API foundation that both .claude/ and ai/ can eventually share. + +**No changes needed to our epics.** Proceed with implementation starting Phase 1. From 74b59b45bef96f1e12a7ff18131deeea1ebda8c5 Mon Sep 17 00:00:00 2001 From: Claude Date: Tue, 20 Jan 2026 14:53:30 +0000 Subject: [PATCH 5/7] Add master epic overview for RLM + Database + Jiron skills Created comprehensive overview document that provides: - Executive summary and big picture - Visual phase dependencies and implementation order - Concise summary of each phase with deliverables - Architecture decisions with rationale - Value proposition and quantified benefits - Success metrics for each phase - Implementation strategy and risk mitigation - Links to detailed phase epics and research docs - Relationship to janhesters' work Makes it easy to absorb the entire 5-phase epic structure at a glance before diving into detailed task lists. --- tasks/EPIC-rlm-database-jiron-skills.md | 541 ++++++++++++++++++++++++ 1 file changed, 541 insertions(+) create mode 100644 tasks/EPIC-rlm-database-jiron-skills.md diff --git a/tasks/EPIC-rlm-database-jiron-skills.md b/tasks/EPIC-rlm-database-jiron-skills.md new file mode 100644 index 0000000..c743e9d --- /dev/null +++ b/tasks/EPIC-rlm-database-jiron-skills.md @@ -0,0 +1,541 @@ +# RLM + Database + Jiron Skills: Master Epic + +**Status**: 📋 PLANNED +**Start Date**: 2026-01-20 +**Goal**: Transform aidd into a database-backed framework with self-documenting APIs and recursive codebase exploration capabilities + +--- + +## 🎯 Executive Summary + +Build a comprehensive skill ecosystem that enables AI agents to deeply understand and work with complex codebases through: + +1. **SQLite Foundation** - Queryable database for all project metadata +2. **Jiron APIs** - Self-documenting, AI-friendly API layer +3. **Rich Querying** - Fan-out search combining keyword, semantic, and structured queries +4. **Database-Backed Story Maps** - ProductManager skill with SQL power +5. **Recursive Exploration** - RLM skill for handling codebases beyond context limits + +**Key Innovation**: Treat the codebase as an external environment that agents can programmatically explore through recursive decomposition, extending effective context by 100x. + +--- + +## 📊 Phase Overview + +### Phase Dependencies + +``` +Phase 1: SQLite Foundation + Indexing + Fan-out Search +├─ No dependencies (foundational) +├─ Deliverable: Database schema, indexers, query tools +└─ Duration: Foundation for all phases + + ├─→ Phase 2: Jiron DB API Skill + │ ├─ Depends on: Phase 1 + │ ├─ Deliverable: Generic API generation from SudoLang → Jiron + │ └─ Duration: Reusable for any database-backed API + │ + │ ├─→ Phase 3: Frontmatter Index Jiron API + │ │ ├─ Depends on: Phase 1, Phase 2 + │ │ ├─ Deliverable: Self-documenting codebase query API + │ │ └─ Duration: Powers RLM exploration + │ │ + │ └─→ Phase 4: ProductManager Skill Conversion + │ ├─ Depends on: Phase 1, Phase 2 + │ ├─ Deliverable: Database-backed story maps with Jiron API + │ └─ Duration: Rich querying for product data + │ + └─→ Phase 5: RLM Skill + ├─ Depends on: All phases (1, 2, 3, 4) + ├─ Deliverable: Recursive codebase exploration skill + └─ Duration: Capstone bringing everything together +``` + +### Implementation Order + +**Sequential with parallel opportunities:** + +1. **Phase 1** - Start immediately (no blockers) +2. **Phase 2** - Start after Phase 1 database operational +3. **Phase 3 & 4** - Can proceed in parallel (both need Phase 1 + 2) +4. **Phase 5** - Final integration (needs all previous phases) + +--- + +## 🔍 Phase Details + +### Phase 1: SQLite Foundation + Indexing + Fan-out Search + +**What**: Core database infrastructure and search capabilities + +**Deliverables**: +- SQLite schema (documents, dependencies, productmanager tables) +- Frontmatter indexer with FTS5 full-text search +- Dependency graph indexer and traversal +- Fan-out search (keyword + semantic + structured) +- CLI tools for indexing and querying +- Git configuration for committing SQLite databases + +**Key Files**: +- `.aidd/index.db` - SQLite database (committed to git) +- `ai/tools/index-frontmatter.js` - Frontmatter extraction +- `ai/tools/index-dependencies.js` - Import graph builder +- `ai/tools/query.js` - Unified query CLI +- `ai/tools/fan-out-search.js` - Multi-strategy search + +**Why This Matters**: +- Foundation for all subsequent phases +- Enables rich querying impossible with YAML +- Database committed to git (clone and go) +- Change detection for incremental updates + +**Success Criteria**: +- [ ] Schema creates all tables with indexes +- [ ] Indexers handle 100+ files in <1 second +- [ ] FTS5 search finds relevant content +- [ ] Fan-out search aggregates multiple strategies +- [ ] All unit tests pass (>90% coverage) + +**Epic Document**: [`tasks/phase-1-sqlite-foundation.md`](../tasks/phase-1-sqlite-foundation.md) + +--- + +### Phase 2: Jiron DB API Skill + +**What**: Generic skill for generating self-documenting APIs from SudoLang schemas + +**Deliverables**: +- `ai/skills/jiron/SKILL.md` - Teaches agents Jiron protocol +- `ai/skills/jiron-db-api/` - API generation skill and tools +- SudoLang interface parser +- Jiron endpoint generator (pug syntax) +- SQLite query bridge +- Middleware integration with aidd server utilities + +**Key Capabilities**: +- Parse SudoLang interface definitions +- Generate Jiron API endpoints with hypermedia links +- Connect to SQLite for CRUD operations +- Expose fan-out search via Jiron endpoints +- Self-documenting, progressive discovery + +**Why This Matters**: +- Reusable for any database-backed API (not just aidd) +- AI-friendly token-efficient protocol +- Hypermedia enables agent navigation +- Foundation for Phase 3 and 4 APIs + +**Success Criteria**: +- [ ] SudoLang → Jiron generation works +- [ ] Generated APIs functional with SQLite +- [ ] Fan-out search exposed via endpoints +- [ ] Middleware integration complete +- [ ] Skills follow Agent Skills spec + +**Epic Document**: [`tasks/phase-2-jiron-db-api-skill.md`](../tasks/phase-2-jiron-db-api-skill.md) + +--- + +### Phase 3: Frontmatter Index Jiron API + +**What**: Apply Jiron skill to expose frontmatter index as self-documenting API + +**Deliverables**: +- SudoLang schema for documents and dependencies +- Generated Jiron API for codebase queries +- Search endpoint with fan-out capabilities +- Dependency traversal API +- API server and documentation + +**Key Endpoints**: +- `GET /api/documents` - List/filter documents +- `GET /api/documents/:path` - Document detail +- `GET /api/search` - Fan-out search +- `GET /api/traverse/:path` - Recursive dependencies +- `GET /api/dependencies/graph` - Full dep graph + +**Why This Matters**: +- Programmatic codebase exploration +- Self-documenting for AI agents +- Foundation for RLM recursive queries +- Progressive discovery through links + +**Success Criteria**: +- [ ] SudoLang schema complete +- [ ] Jiron API generated and functional +- [ ] Search integrates fan-out capabilities +- [ ] Traversal navigates dependency graph +- [ ] API server operational + +**Epic Document**: [`tasks/phase-3-frontmatter-jiron-api.md`](../tasks/phase-3-frontmatter-jiron-api.md) + +--- + +### Phase 4: ProductManager Skill Conversion + +**What**: Convert productmanager from rule to full skill with database backing + +**Deliverables**: +- `ai/skills/productmanager/SKILL.md` - Full Agent Skill +- SudoLang schema for all productmanager entities +- Generated Jiron API for story maps +- SQLite as source of truth (YAML export optional) +- Import tool for existing YAML data + +**Key Capabilities**: +- Rich queries: "High-priority stories for persona X" +- Aggregations: AVG priority, story counts by status +- Foreign keys ensure data integrity +- Complex joins across personas, journeys, steps, stories +- YAML export for stakeholder review + +**Why This Matters**: +- YAML doesn't scale to complex products (100+ stories) +- SQL enables dashboard, analytics, impact analysis +- Database-backed workflows more robust +- Foundation for connecting code to requirements + +**Success Criteria**: +- [ ] SudoLang schema complete +- [ ] Jiron API functional +- [ ] Existing YAML imported successfully +- [ ] Validates against original productmanager.mdc +- [ ] YAML export works on demand + +**Epic Document**: [`tasks/phase-4-productmanager-skill.md`](../tasks/phase-4-productmanager-skill.md) + +--- + +### Phase 5: RLM Skill + +**What**: Recursive Language Model skill for deep codebase exploration + +**Deliverables**: +- `ai/skills/rlm/SKILL.md` - Complete recursive exploration skill +- Decomposition patterns documentation +- Integration with all Jiron APIs +- AGENTS.md usage guidelines +- User journey with pain points + +**Key Capabilities**: +- Recursive task decomposition +- Fan-out search orchestration +- Dependency graph traversal +- Result aggregation and synthesis +- Handles codebases 100x beyond context limits + +**Decomposition Example**: +``` +Query: "How does authentication work?" +├─ Decompose: ["Find auth files", "Trace deps", "Extract logic"] +├─ Fan out: Parallel searches (keyword + semantic + metadata) +├─ Traverse: Dependencies of each auth file +├─ Recurse: Deep dive on complex dependencies +└─ Synthesize: Complete auth flow explanation +``` + +**Why This Matters**: +- Solves context window limitations +- Enables architectural understanding +- AI agents become more effective on large codebases +- Differentiator for aidd framework + +**Success Criteria**: +- [ ] User journey documented +- [ ] Decomposition strategy defined +- [ ] SKILL.md complete with examples +- [ ] AGENTS.md updated +- [ ] Real query testing validates effectiveness + +**Epic Document**: [`tasks/phase-5-rlm-skill.md`](../tasks/phase-5-rlm-skill.md) + +--- + +## 🎨 Architecture Decisions + +### 1. SQLite as Source of Truth +**Decision**: Commit `.aidd/index.db` to git, YAML export optional + +**Rationale**: +- No sync issues (single source) +- Rich queries, relationships, aggregations +- Git-friendly with proper config +- Clone repo → everything works + +**Trade-offs**: +- Binary file in git (mitigated by textconv) +- Learning curve for SQL queries +- Worth it for query power + +### 2. Jiron Protocol for APIs +**Decision**: Use Jiron for all database-backed APIs + +**Rationale**: +- Self-documenting (agents discover capabilities) +- Token-efficient vs JSON +- Progressive discovery via hypermedia +- Pug syntax is terse and expressive + +**Trade-offs**: +- Newer protocol (less tooling) +- Learning curve for developers +- But massive benefit for AI agents + +### 3. Hybrid Implementation +**Decision**: SudoLang for AI logic, JavaScript/Bun for symbolic processing + +**Rationale**: +- SudoLang for decision-making, decomposition, synthesis +- JS/Bun for indexing, queries, graph traversal +- TDD for all symbolic code +- Right tool for each job + +### 4. Skills Location: `ai/skills/` +**Decision**: Framework-agnostic location, not `.claude/` + +**Rationale**: +- Works with any Agent Skills tool +- Consistent with `ai/rules/`, `ai/commands/` +- Not tied to Claude Code +- Better for aidd framework users + +### 5. Always-Surfaced RLM +**Decision**: RLM skill has `alwaysApply: true`, agent decides when to use + +**Rationale**: +- Proactive context gathering +- No user friction +- Agent learns when deep exploration valuable +- AGENTS.md provides usage guidance + +--- + +## 💡 Value Proposition + +### Problems Solved + +**1. Context Window Limitations** +- Current: Agents struggle with codebases >100 files +- With RLM: Handle projects 100x beyond context limits +- Value: Better answers, fewer hallucinations + +**2. YAML Doesn't Scale** +- Current: Complex story maps become unmanageable YAML +- With SQLite: Rich queries, aggregations, relationships +- Value: Product data becomes analyzable + +**3. Manual Code Discovery** +- Current: Agents miss relevant files, incomplete answers +- With Fan-out + Jiron: Comprehensive search, dependency traversal +- Value: Complete context for better decisions + +**4. No API Layer** +- Current: Direct file manipulation, no self-documentation +- With Jiron: Progressive discovery, hypermedia affordances +- Value: Agents navigate data programmatically + +### Quantified Benefits + +**Performance**: +- Indexing: 100 files in <1 second +- Queries: <200ms for typical searches +- Context scaling: 100x beyond model limits + +**Developer Experience**: +- Faster onboarding to complex codebases +- Better architectural understanding +- Reduced context switching +- More accurate agent responses + +**Framework Capabilities**: +- Foundation for future enhancements (vector search, AST analysis) +- Reusable patterns (Jiron skill works for any DB) +- Extensible architecture + +--- + +## 🚧 Implementation Strategy + +### Incremental Delivery + +**Each phase ships independently**: +- Phase 1: Database + tools usable immediately +- Phase 2: Jiron skill reusable for other projects +- Phase 3: Frontmatter API enables codebase queries +- Phase 4: ProductManager skill upgrade +- Phase 5: RLM brings it all together + +### Testing Approach + +**Per Phase**: +- Unit tests for all JavaScript (TDD with vitest + riteway) +- Integration tests with real aidd data +- Performance benchmarks +- SudoLang validation through agent self-prompting + +**Phase 5 Final**: +- End-to-end recursive exploration tests +- Real-world query validation +- Performance optimization +- User acceptance testing + +### Risk Mitigation + +**Database Adoption**: +- Import existing YAML to ease transition +- Export tools for YAML workflows +- Backward compatible approach + +**Complexity Management**: +- Incremental phases reduce risk +- Each phase valuable on its own +- Can stop at any phase if needed + +**Agent Effectiveness**: +- Clear guidelines in AGENTS.md +- Examples for common patterns +- Self-documenting APIs help discovery + +--- + +## 📈 Success Metrics + +### Phase 1 +- [ ] Index all aidd .md/.mdc files successfully +- [ ] FTS5 search finds relevant content +- [ ] Dependency graph complete and queryable +- [ ] Performance: <1s for 100 files + +### Phase 2 +- [ ] Generate working Jiron API from SudoLang +- [ ] API supports CRUD on SQLite +- [ ] Fan-out search exposed via endpoints +- [ ] Reusable for other projects + +### Phase 3 +- [ ] Codebase queryable via Jiron API +- [ ] Search returns comprehensive results +- [ ] Dependency traversal works at depth 5 +- [ ] API documentation complete + +### Phase 4 +- [ ] All productmanager workflows in database +- [ ] Complex queries work (joins, aggregations) +- [ ] Validates against original productmanager.mdc +- [ ] YAML import/export functional + +### Phase 5 +- [ ] RLM handles complex architectural queries +- [ ] Recursive decomposition logical and complete +- [ ] Results better than simple search +- [ ] Agents use skill appropriately + +### Overall +- [ ] All 5 phases complete and integrated +- [ ] Documentation comprehensive +- [ ] Tests pass (unit + integration) +- [ ] Real-world validation successful +- [ ] Ready for production use + +--- + +## 📚 Documentation + +### Research Documentation (`plan/rlm/`) +- [`research-summary.md`](../plan/rlm/research-summary.md) - Overview +- [`agent-skills-spec.md`](../plan/rlm/agent-skills-spec.md) - Agent Skills specification +- [`rlm-paper-findings.md`](../plan/rlm/rlm-paper-findings.md) - MIT RLM paper analysis +- [`implementation-architecture.md`](../plan/rlm/implementation-architecture.md) - Technical architecture +- [`database-design.md`](../plan/rlm/database-design.md) - Complete SQLite schema +- [`review-janhesters-branch.md`](../plan/rlm/review-janhesters-branch.md) - Compatibility analysis + +### Phase Epics (`tasks/`) +- [`phase-1-sqlite-foundation.md`](../tasks/phase-1-sqlite-foundation.md) +- [`phase-2-jiron-db-api-skill.md`](../tasks/phase-2-jiron-db-api-skill.md) +- [`phase-3-frontmatter-jiron-api.md`](../tasks/phase-3-frontmatter-jiron-api.md) +- [`phase-4-productmanager-skill.md`](../tasks/phase-4-productmanager-skill.md) +- [`phase-5-rlm-skill.md`](../tasks/phase-5-rlm-skill.md) + +--- + +## 🤝 Relationship to Existing Work + +### janhesters' Claude Code Skills (`.claude/skills/`) +**Status**: Compatible, complementary + +**His Approach**: +- YAML-based workflows +- Claude Code specific (`.claude/` directory) +- Lightweight, quick to use + +**Our Approach**: +- Database-backed workflows +- Framework-agnostic (`ai/skills/` directory) +- Rich querying and APIs + +**Coexistence**: +- Both can exist side-by-side +- Different use cases and audiences +- Potential future convergence: `ai/skills/` powers both + +**Recommendation**: Suggest moving `.claude/skills/` → `ai/skills/` for broader compatibility + +### Existing AIDD Framework +**Integration Points**: +- Extends existing `ai/rules/` and `ai/commands/` +- Adds `ai/skills/` for Agent Skills spec +- Preserves backward compatibility +- Enhances, doesn't replace + +--- + +## 🚀 Getting Started + +### Phase 1 First Steps +1. Create `.aidd/` directory +2. Implement SQLite schema creation script +3. Build frontmatter indexer with TDD +4. Test with real aidd files +5. Validate performance targets + +### For Contributors +1. Read this overview +2. Review specific phase epic for details +3. Check research docs for context +4. Start with Phase 1 if implementing +5. Reach out with questions + +### For Reviewers +1. Review this overview for big picture +2. Validate phase dependencies make sense +3. Check value proposition aligns with goals +4. Review technical decisions +5. Provide feedback on approach + +--- + +## 📅 Timeline Estimate + +**Note**: Focus on what needs doing, not when (per AIDD principles) + +**Rough Sequence**: +- Phase 1: Foundational (start immediately) +- Phase 2: After Phase 1 operational +- Phase 3 & 4: Parallel after Phase 2 +- Phase 5: Integration after all phases + +**Incremental Delivery**: Each phase ships as completed, providing value immediately + +--- + +## ✅ Next Actions + +1. **Review this overview** - Ensure big picture clear +2. **Start Phase 1** - Begin implementation +3. **Coordinate with janhesters** - Discuss skill directory location +4. **Document as we go** - Update this overview with learnings +5. **Celebrate milestones** - Each phase completion is progress + +--- + +**Questions? Start with this overview, then dive into specific phase epics for details.** From 82be9dae35cc0ed8e123913e4b5d60b1d6ebfaad Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 21 Jan 2026 00:09:20 +0000 Subject: [PATCH 6/7] Add SQLite schema foundation for document indexing Creates database-backed indexing system with FTS5 full-text search, dependency tracking, and ProductManager entities. Replaces YAML as source of truth for project metadata. Implements Phase 1 foundation for Recursive Language Model skill. --- .aidd/index.db | Bin 0 -> 208896 bytes .gitattributes | 11 + ai/rules/index.md | 4 + ai/rules/sudolang/index.md | 12 + ai/tools/create-schema.js | 282 +++++++ ai/tools/create-schema.test.js | 305 +++++++ ai/tools/index.md | 5 + bun.lock | 1387 ++++++++++++++++++++++++++++++++ package.json | 4 +- 9 files changed, 2009 insertions(+), 1 deletion(-) create mode 100644 .aidd/index.db create mode 100644 .gitattributes create mode 100644 ai/rules/sudolang/index.md create mode 100755 ai/tools/create-schema.js create mode 100644 ai/tools/create-schema.test.js create mode 100644 ai/tools/index.md create mode 100644 bun.lock diff --git a/.aidd/index.db b/.aidd/index.db new file mode 100644 index 0000000000000000000000000000000000000000..318ebcb306bbafc626576aadb7c7bc8f02888a5b GIT binary patch literal 208896 zcmeI*&2t;)eZX-pNdY89nv!LCZPPTL*k*u@DN(ShXgV6zrO1`chz4yEw5;hk7zkLB zu<$|wOIh+{CIecT=8{7$>0~;SLz_bn=_!9gF1hv6t9z+$ZKs#|;PIu;zC4RvEEclb zW%zU3%yQynH#(Ki?2^Ph3CI<$}G%(GxvwNz1c5kUp@WX)B4OWXUN9}h>6%VHODlcdC#YOG&^LFK4!}_Fs+-X^l zyXwyu*LTddk||1SH?~ZnQbm47xIgupD48FX#QQs&@2&0J6}Qd1D}Gk1(zLwH;&w?C z_qMiFPR;68JM|;G-fp=CRC={zRcxzPmY$o%l6lMA5rc;wAJv{#q-og|S*Rj@w7Xq& z+hVM~lF`=}wXu4uWp$^FR>oE58jJ~?4HRFLCKXt?l$st_kaOF;d(W{&f zkE*Ii{rP-kR8{JCZB$dVX8lSOy22v;0_Jr|i?;hbQK1$7QzBK+PB&kP|C zFVLvBta9tPdC%&ol|-#E>R9WM{j6(GXpIy3p#3YtZ|jOsb<25Vcni$NN1FKVOSC5-k%kGx<`23_xdHAYQ&v)%^g#8+MmiL|GH>5Y8Tzt z*W8Yp#f_6o&$%srq7QAczi_LdBU|j1^;^96{)Y4Ulh|TEKj@CrSpO4f*DU$3gm6x7 z+3uG0=|$(Inhru#+bvtV`g#7lezqLvmMuTwZL3qZok??Dd?G&x%JOBWQnm9=g`qMl zBKKy_8+`F}vfVk4?Bk(i^;XyF*g?lel6hr)vd!YIxl>9e^Yi6r>~?gJ^X`zYh@*;q zDCf1~qg9)PTYKhiaAFJB*sCbeca+>pBPr2=aLUB^zqPdyOvFdCS^dft zt#{5_qSTCY&jnfke*GXI4W-R0UU#398&)KjzaQD>h=+!_vsrp~d#@yRw(o3i{N%J; zimz%teMn?kVYmKS|CDt@`-!JV#rDhO^76b>yQ0uav?98ni5pwnH;mrIj2C`+NO&JM z)-7l1&x{K1ADA4zdP&Zag8Y43{$4hEGt*gpbye%F4{3$m8%0|n6Q)N+m-)GT*E*=z zfdP3qmDLM{gaMIT#AsujP2<$4);I-{A?`KW)%*TXnAxnJ z%T1l!jw3{3`q4hz+$rs?ZTXw*NC~mGyIH&?!XVW4-E00_Cs@#_Ru#j`lQ=^^9>hCORy}AD0A~>Cz?OJ`m?(Wuu z250^L^moERRykBYvNGjE8Ajt&R=+L-P7ev_CPm|AM#SqEkA~}~8+Ru&dSOX>FeI3x z8MOV>h%ipUXaFb0I5{(()t8pE&)d-%5Y##0*XdnX1JDwkIEpC1GeKmY**5I_I{1Q0*~0R#|8v4Haw0N4L19$>nL00IagfB*srAb1Q0*~0R#|0 z009ILKmY**(jdU~e;P)SJ|KVq0tg_000IagfB*srATV0MdH!FU|DQ4W4?hSXfB*sr zAb5I_I{1Q0*~0R#|0AVmUP|EFj$=?Ve}AbmG) zkc^5@1M1 z009ILKmY**5I_I{1Q0+VMFQOaPtjn~6$B7K009ILKmY**5I_I{1QGy@fB*srAbtgp0tg_0 z00IagfB*srAb>!M1i1g7qQRsq2q1s}0tg_000IagfB*srBnWW*p8!KL0tg_000Iag zfB*srAb=v9Gn?jXn5w5WULFS$%O)`~19Jxwp5F(N`C>X1!Ij z9@T4)%Ad54J1y&Rx7?~UE%oN5^&NAqWQxt=hWU|*6%*SEtw__dE3!~U{AhQ(=(fc;d?~A6 zThw}|0_-EJ(`~mZ-Eu#sN;)4SS2>}=4!lav_v=bMZL3^4w%hLevZ}URP_NGQD(CxCtzoHj_2=`EX`oWSW24%9A*)|q z)_SLdQLV|2%G0S;ty|r){rJcVC!CF;hjZQH&ZveH^Y!LYyJNd~M(tcizr3vdG$C3$ zeBha<#A?SP+3oUvyy!W=F)7nx?^oM5U2jTydF_$T%O* z+1>KK{H<9HOD=pWO{wi{-g4H!AU#x8tlcchtPOL^l%EdHv{eU-8|JM|Z`~6r|K`s2 zd;JnlHR8^@=8h>k?N8+jeqFR1wTtfSYi@hZ;>O9P=iC-Q(TBF!Ux!uDkuCPh`Yqmj zf5Z7aOKh>9A9TlQtp9?+)pTII7r(a(X&W%4bD{dg)52UVgZ?wP)@I=cjOuy@~>T zN6D=;k`f&Vr%a6hTU#5!M0_-x)vsL9dgr{AM$I_)T#)te*AD{HP};2Gb@w^BVMTKJ z`;l#ncxZ?_o27TR_ex@C`_AUZPfp9F_^Q^^heVbYcI%(@Pgys#pLlvyY`;t{FV8!* z$q6keE28_ExUsc;!{|-Sc;T0ag!f@%-EyY>%&74Gfyv>km*gBN$ltf+?`5MmGo95} zSGC^ykXFd;XtV_~VR}?_nV-vdt%G_^PDiWLlvDGd)m{k?Lpa+Q7?6ikS-nt57!bMR zi#EpD15S-0f*VS>;gq$jX!tWf+Z9S^c^UI6Wkw zn-qZZqXC>04+>Bn)qk!U$x5Ie`;^f z{c7&Q>>p>_v(q#GIQH)|ugSyWKfU?C$m)N2P3v6^zK`ly502{{%e(K>?$oT#{&B17 z+y<{S%Hhn*v2Uotxn=iI=Ub|T!}DFc-FaMgzGZcbmfaQ@@4cPTE7y{~u}P?_Tu8_$ zTzD&^uPr21=QP2&3tRAC{NRBhzkGZn{N>|OrQRwZ$$Qw&T`;GE^2Y7sP+~r&5X$Ty z;Xs5ky z+SXC{5fJzNo3UvySj?FOZd&-skMf&Y{VhHGUAK3bdj`5M-$khPDJ=x=Q<@JOJewlu|`!S4@{qJRUUDtm0miJ|>Q;*va5t*)DlDcOxVxsn| z9{y$Yvp*ITTEi0O(Vt+)`?pWKyq^$bVZ zzc0VOw!6NzVS3*%8?R^d>w40pb$y-HQu2SVH!iZec|q$f1%s^ut7mo8LqCJ*OR*_1 zSVA4?v~w^o?^iD;pV1p%dTJy5;|HsG?dgs14;k7BRh?|a$p?#B{lW$9$(}nqRgO{^ zeE(`>&JN}V>#WL9(^##IYRLNv!{>15hHZFC$lICTV`UDXs_XwheTLQ)iWHuR3TD(q zeCM@{zI!2QA}SkIQ@JphvUvFF;Nx_Dk?>lol3q!g3*o|{Y0wQXs(+@3Bv)S<^*Ehs zdC>E&-W$K{ZRQq(6EdP2n0P#be{wEwBZ03xUYC*bR)1G*@%@WEdBwvc0 z83~1g6GWXDp^2_$q1syxKQjg&?TkIZ`6pV;BM*71rbSLQ)y~K|?Qcd$ogKAHa-&C$a>9Vi2Ui-SWDyk{l)| z8VMAnI*Vv&C8J+h(7fkdou{8w9QSk5i||%r1gB8AZs)yI>yxuT$m$CV+TT9*w>&Pk zU$x;^=iSNo6TjVw;nwb+7ivcKcb_tDBaF)X?Sqch?K#H1i1cB+lbO11Q0*~0R#|0009ILKmY**;sX5l|8Wyi5I_I{1Q0*~0R#|0009IL zNSgrn|I;?2^alY15I_I{1Q0*~0R#|00D-sw*Z*-7QV>7@0R#|0009ILKmY**5J;N< z*Z*l7QTl@b0tg_000IagfB*srAb>zzfb0Lb2`LC5fB*srAb9{?2LS{SKmY** z5I_I{1Q0*~fw%zI|8Wyi5I_I{1Q0*~0R#|0009ILNSgrH|7jah`hx%h2q1s}0tg_0 z00IagfIwV;|NmdygcJl2KmY**5I_I{1Q0*~0R++}!2SQUjVS#=009ILKmY**5I_I{ z1Q0+VF2MDF+=LVa5I_I{1Q0*~0R#|0009KjCcyQ7+D4TAAb personas + db.exec(` + CREATE TABLE IF NOT EXISTS journey_personas ( + journey_id TEXT NOT NULL, + persona_id TEXT NOT NULL, + PRIMARY KEY (journey_id, persona_id), + FOREIGN KEY (journey_id) REFERENCES journeys(id) ON DELETE CASCADE, + FOREIGN KEY (persona_id) REFERENCES personas(id) ON DELETE CASCADE + ) + `); + + db.exec(` + CREATE INDEX IF NOT EXISTS idx_journey_personas_journey ON journey_personas(journey_id); + CREATE INDEX IF NOT EXISTS idx_journey_personas_persona ON journey_personas(persona_id); + `); + + // Steps + db.exec(` + CREATE TABLE IF NOT EXISTS steps ( + id TEXT PRIMARY KEY, + journey_id TEXT NOT NULL, + name TEXT NOT NULL, + description TEXT, + order_index INTEGER NOT NULL, + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + metadata JSON, + FOREIGN KEY (journey_id) REFERENCES journeys(id) ON DELETE CASCADE + ) + `); + + db.exec(` + CREATE INDEX IF NOT EXISTS idx_steps_journey ON steps(journey_id); + CREATE INDEX IF NOT EXISTS idx_steps_order ON steps(journey_id, order_index); + CREATE INDEX IF NOT EXISTS idx_steps_created_at ON steps(created_at); + `); + + // Pain Points + db.exec(` + CREATE TABLE IF NOT EXISTS pain_points ( + id TEXT PRIMARY KEY, + name TEXT NOT NULL, + description TEXT, + impact INTEGER NOT NULL CHECK(impact BETWEEN 1 AND 10), + frequency INTEGER NOT NULL CHECK(frequency BETWEEN 1 AND 10), + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + metadata JSON + ) + `); + + db.exec(` + CREATE INDEX IF NOT EXISTS idx_pain_points_impact ON pain_points(impact); + CREATE INDEX IF NOT EXISTS idx_pain_points_frequency ON pain_points(frequency); + `); + + // Stories + db.exec(` + CREATE TABLE IF NOT EXISTS stories ( + id TEXT PRIMARY KEY, + step_id TEXT, + pain_point_id TEXT, + name TEXT NOT NULL, + description TEXT, + priority INTEGER, + status TEXT CHECK(status IN ('backlog', 'inProgress', 'released', 'cancelled')), + created_at INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + metadata JSON, + FOREIGN KEY (step_id) REFERENCES steps(id) ON DELETE SET NULL, + FOREIGN KEY (pain_point_id) REFERENCES pain_points(id) ON DELETE SET NULL + ) + `); + + db.exec(` + CREATE INDEX IF NOT EXISTS idx_stories_step ON stories(step_id); + CREATE INDEX IF NOT EXISTS idx_stories_pain_point ON stories(pain_point_id); + CREATE INDEX IF NOT EXISTS idx_stories_priority ON stories(priority DESC); + CREATE INDEX IF NOT EXISTS idx_stories_status ON stories(status); + CREATE INDEX IF NOT EXISTS idx_stories_created_at ON stories(created_at); + `); + + // Functional Requirements + db.exec(` + CREATE TABLE IF NOT EXISTS functional_requirements ( + id TEXT PRIMARY KEY, + story_id TEXT NOT NULL, + description TEXT NOT NULL, + order_index INTEGER NOT NULL, + created_at INTEGER NOT NULL, + metadata JSON, + FOREIGN KEY (story_id) REFERENCES stories(id) ON DELETE CASCADE + ) + `); + + db.exec(` + CREATE INDEX IF NOT EXISTS idx_requirements_story ON functional_requirements(story_id); + CREATE INDEX IF NOT EXISTS idx_requirements_order ON functional_requirements(story_id, order_index); + `); + + // Record schema version + const version = 1; + const now = Date.now(); + + const existing = db.prepare('SELECT version FROM schema_version WHERE version = ?').get(version); + if (!existing) { + db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(version, now); + } + + return { version, tablesCreated: true }; +} + +/** + * Main execution when run as script + */ +if (import.meta.main) { + const dbPath = process.argv[2] || '.aidd/index.db'; + + console.log(`Creating schema in ${dbPath}...`); + + const db = new Database(dbPath); + const result = createSchema(db); + + console.log(`✓ Schema created successfully (version ${result.version})`); + + // Show table count + const tables = db.prepare(` + SELECT COUNT(*) as count + FROM sqlite_master + WHERE type='table' AND name NOT LIKE 'sqlite_%' + `).get(); + + console.log(`✓ Created ${tables.count} tables`); + + db.close(); +} diff --git a/ai/tools/create-schema.test.js b/ai/tools/create-schema.test.js new file mode 100644 index 0000000..e04c413 --- /dev/null +++ b/ai/tools/create-schema.test.js @@ -0,0 +1,305 @@ +import { describe, test, beforeEach, afterEach } from 'vitest'; +import { assert } from 'riteway/vitest'; +import { Database } from 'bun:sqlite'; +import { createSchema } from './create-schema.js'; + +describe('createSchema()', async () => { + let db; + + beforeEach(async () => { + // Create in-memory database for fast tests + db = new Database(':memory:'); + }); + + afterEach(async () => { + if (db) db.close(); + }); + + test('should return version and success status', async () => { + const result = createSchema(db); + + assert({ + given: 'schema creation', + should: 'return version 1', + actual: result.version, + expected: 1 + }); + + assert({ + given: 'schema creation', + should: 'indicate tables were created', + actual: result.tablesCreated, + expected: true + }); + }); + + test('should create documents table', async () => { + createSchema(db); + + const tableInfo = db.prepare(` + SELECT name FROM sqlite_master + WHERE type='table' AND name='documents' + `).get(); + + assert({ + given: 'schema creation', + should: 'create documents table', + actual: tableInfo?.name, + expected: 'documents' + }); + }); + + test('should create documents table with correct columns', async () => { + createSchema(db); + + const columns = db.prepare(` + PRAGMA table_info(documents) + `).all(); + + const columnNames = columns.map(c => c.name).sort(); + const expectedColumns = ['path', 'type', 'frontmatter', 'content', 'hash', 'indexed_at', 'file_size', 'modified_at'].sort(); + + assert({ + given: 'documents table', + should: 'have all required columns', + actual: JSON.stringify(columnNames), + expected: JSON.stringify(expectedColumns) + }); + }); + + test('should create FTS5 virtual table', async () => { + createSchema(db); + + const tableInfo = db.prepare(` + SELECT name FROM sqlite_master + WHERE type='table' AND name='documents_fts' + `).get(); + + assert({ + given: 'schema creation', + should: 'create documents_fts virtual table', + actual: tableInfo?.name, + expected: 'documents_fts' + }); + }); + + test('should create dependencies table', async () => { + createSchema(db); + + const tableInfo = db.prepare(` + SELECT name FROM sqlite_master + WHERE type='table' AND name='dependencies' + `).get(); + + assert({ + given: 'schema creation', + should: 'create dependencies table', + actual: tableInfo?.name, + expected: 'dependencies' + }); + }); + + test('should create productmanager tables', async () => { + createSchema(db); + + const tables = db.prepare(` + SELECT name FROM sqlite_master + WHERE type='table' AND name IN ( + 'personas', 'journeys', 'journey_personas', 'steps', + 'pain_points', 'stories', 'functional_requirements' + ) + ORDER BY name + `).all(); + + assert({ + given: 'schema creation', + should: 'create all 7 productmanager tables', + actual: tables.length, + expected: 7 + }); + }); + + test('should create indexes for documents table', async () => { + createSchema(db); + + const indexes = db.prepare(` + SELECT name FROM sqlite_master + WHERE type='index' AND tbl_name='documents' + `).all(); + + assert({ + given: 'documents table', + should: 'create at least 3 indexes', + actual: indexes.length >= 3, + expected: true + }); + }); + + test('should enable foreign keys', async () => { + createSchema(db); + + const result = db.query('PRAGMA foreign_keys').get(); + const fkStatus = result?.foreign_keys; + + assert({ + given: 'schema creation', + should: 'enable foreign key constraints', + actual: fkStatus, + expected: 1 + }); + }); + + test('should record schema version', async () => { + createSchema(db); + + const version = db.prepare(` + SELECT version FROM schema_version WHERE version = 1 + `).get(); + + assert({ + given: 'schema creation', + should: 'record schema version 1', + actual: version?.version, + expected: 1 + }); + }); + + test('should create FTS5 triggers', async () => { + createSchema(db); + + const triggers = db.prepare(` + SELECT name FROM sqlite_master + WHERE type='trigger' AND name LIKE 'documents_fts_%' + `).all(); + + assert({ + given: 'schema creation', + should: 'create 3 FTS5 triggers (insert, update, delete)', + actual: triggers.length, + expected: 3 + }); + }); + + test('should enforce foreign key constraints', async () => { + createSchema(db); + + let errorThrown = false; + let errorMessage = ''; + + try { + db.prepare(` + INSERT INTO stories ( + id, step_id, name, priority, status, created_at, updated_at + ) VALUES ( + 'story1', 'nonexistent', 'Test Story', 50, 'backlog', ?, ? + ) + `).run(Date.now(), Date.now()); + } catch (error) { + errorThrown = true; + errorMessage = error.message; + } + + assert({ + given: 'invalid foreign key', + should: 'throw foreign key constraint error', + actual: errorThrown && errorMessage.includes('FOREIGN KEY'), + expected: true + }); + }); + + test('should be idempotent', async () => { + createSchema(db); + const result2 = createSchema(db); + + const versionCount = db.prepare(` + SELECT COUNT(*) as count FROM schema_version WHERE version = 1 + `).get(); + + assert({ + given: 'multiple schema creation calls', + should: 'not duplicate schema version records', + actual: versionCount.count, + expected: 1 + }); + }); + + test('should create indexes for dependency traversal', async () => { + createSchema(db); + + const indexes = db.prepare(` + SELECT name FROM sqlite_master + WHERE type='index' AND tbl_name='dependencies' + ORDER BY name + `).all(); + + const indexNames = indexes.map(i => i.name); + + assert({ + given: 'dependencies table', + should: 'create index on from_file', + actual: indexNames.includes('idx_dependencies_from'), + expected: true + }); + + assert({ + given: 'dependencies table', + should: 'create index on to_file', + actual: indexNames.includes('idx_dependencies_to'), + expected: true + }); + }); + + test('should validate pain point impact range', async () => { + createSchema(db); + + let errorThrown = false; + let errorMessage = ''; + + try { + db.prepare(` + INSERT INTO pain_points ( + id, name, impact, frequency, created_at, updated_at + ) VALUES ( + 'pp1', 'Test Pain', 15, 5, ?, ? + ) + `).run(Date.now(), Date.now()); + } catch (error) { + errorThrown = true; + errorMessage = error.message; + } + + assert({ + given: 'impact value > 10', + should: 'enforce CHECK constraint on impact', + actual: errorThrown && errorMessage.includes('CHECK constraint'), + expected: true + }); + }); + + test('should validate story status values', async () => { + createSchema(db); + + let errorThrown = false; + let errorMessage = ''; + + try{ + db.prepare(` + INSERT INTO stories ( + id, name, status, priority, created_at, updated_at + ) VALUES ( + 'story1', 'Test', 'invalid_status', 50, ?, ? + ) + `).run(Date.now(), Date.now()); + } catch (error) { + errorThrown = true; + errorMessage = error.message; + } + + assert({ + given: 'invalid status value', + should: 'enforce CHECK constraint on status', + actual: errorThrown && errorMessage.includes('CHECK constraint'), + expected: true + }); + }); +}); diff --git a/ai/tools/index.md b/ai/tools/index.md new file mode 100644 index 0000000..4cddd06 --- /dev/null +++ b/ai/tools/index.md @@ -0,0 +1,5 @@ +# tools + +This index provides an overview of the contents in this directory. + +*This directory is empty.* diff --git a/bun.lock b/bun.lock new file mode 100644 index 0000000..04d2e88 --- /dev/null +++ b/bun.lock @@ -0,0 +1,1387 @@ +{ + "lockfileVersion": 1, + "configVersion": 0, + "workspaces": { + "": { + "name": "aidd", + "dependencies": { + "@paralleldrive/cuid2": "^3.1.0", + "@sinclair/typebox": "^0.34.41", + "better-sqlite3": "^12.6.2", + "chalk": "^4.1.2", + "commander": "^11.1.0", + "error-causes": "^3.0.2", + "fs-extra": "^11.1.1", + "gray-matter": "^4.0.3", + "js-sha3": "^0.9.3", + }, + "devDependencies": { + "@eslint/eslintrc": "^3", + "@vitest/coverage-v8": "^3.2.4", + "doctoc": "^2.2.1", + "eslint": "^9", + "eslint-config-prettier": "^10.1.8", + "eslint-plugin-prettier": "^5.5.4", + "husky": "^9.1.7", + "prettier": "^3.6.2", + "release-it": "^19.0.5", + "riteway": "^9.0.0-rc.1", + "typescript": "^5.9.3", + "vitest": "^3.2.4", + }, + "peerDependencies": { + "better-auth": "^1.4.5", + }, + "optionalPeers": [ + "better-auth", + ], + }, + }, + "packages": { + "@ampproject/remapping": ["@ampproject/remapping@2.3.0", "", { "dependencies": { "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw=="], + + "@babel/helper-string-parser": ["@babel/helper-string-parser@7.27.1", "", {}, "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA=="], + + "@babel/helper-validator-identifier": ["@babel/helper-validator-identifier@7.27.1", "", {}, "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow=="], + + "@babel/parser": ["@babel/parser@7.28.4", "", { "dependencies": { "@babel/types": "^7.28.4" }, "bin": { "parser": "bin/babel-parser.js" } }, "sha512-yZbBqeM6TkpP9du/I2pUZnJsRMGGvOuIrhjzC1AwHwW+6he4mni6Bp/m8ijn0iOuZuPI2BfkCoSRunpyjnrQKg=="], + + "@babel/types": ["@babel/types@7.28.4", "", { "dependencies": { "@babel/helper-string-parser": "^7.27.1", "@babel/helper-validator-identifier": "^7.27.1" } }, "sha512-bkFqkLhh3pMBUQQkpVgWDWq/lqzc2678eUyDlTBhRqhCHFguYYGM0Efga7tYk4TogG/3x0EEl66/OQ+WGbWB/Q=="], + + "@bcoe/v8-coverage": ["@bcoe/v8-coverage@1.0.2", "", {}, "sha512-6zABk/ECA/QYSCQ1NGiVwwbQerUCZ+TQbp64Q3AgmfNvurHH0j8TtXa1qbShXA6qqkpAj4V5W8pP6mLe1mcMqA=="], + + "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.25.10", "", { "os": "aix", "cpu": "ppc64" }, "sha512-0NFWnA+7l41irNuaSVlLfgNT12caWJVLzp5eAVhZ0z1qpxbockccEt3s+149rE64VUI3Ml2zt8Nv5JVc4QXTsw=="], + + "@esbuild/android-arm": ["@esbuild/android-arm@0.25.10", "", { "os": "android", "cpu": "arm" }, "sha512-dQAxF1dW1C3zpeCDc5KqIYuZ1tgAdRXNoZP7vkBIRtKZPYe2xVr/d3SkirklCHudW1B45tGiUlz2pUWDfbDD4w=="], + + "@esbuild/android-arm64": ["@esbuild/android-arm64@0.25.10", "", { "os": "android", "cpu": "arm64" }, "sha512-LSQa7eDahypv/VO6WKohZGPSJDq5OVOo3UoFR1E4t4Gj1W7zEQMUhI+lo81H+DtB+kP+tDgBp+M4oNCwp6kffg=="], + + "@esbuild/android-x64": ["@esbuild/android-x64@0.25.10", "", { "os": "android", "cpu": "x64" }, "sha512-MiC9CWdPrfhibcXwr39p9ha1x0lZJ9KaVfvzA0Wxwz9ETX4v5CHfF09bx935nHlhi+MxhA63dKRRQLiVgSUtEg=="], + + "@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.25.10", "", { "os": "darwin", "cpu": "arm64" }, "sha512-JC74bdXcQEpW9KkV326WpZZjLguSZ3DfS8wrrvPMHgQOIEIG/sPXEN/V8IssoJhbefLRcRqw6RQH2NnpdprtMA=="], + + "@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.25.10", "", { "os": "darwin", "cpu": "x64" }, "sha512-tguWg1olF6DGqzws97pKZ8G2L7Ig1vjDmGTwcTuYHbuU6TTjJe5FXbgs5C1BBzHbJ2bo1m3WkQDbWO2PvamRcg=="], + + "@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.25.10", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-3ZioSQSg1HT2N05YxeJWYR+Libe3bREVSdWhEEgExWaDtyFbbXWb49QgPvFH8u03vUPX10JhJPcz7s9t9+boWg=="], + + "@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.25.10", "", { "os": "freebsd", "cpu": "x64" }, "sha512-LLgJfHJk014Aa4anGDbh8bmI5Lk+QidDmGzuC2D+vP7mv/GeSN+H39zOf7pN5N8p059FcOfs2bVlrRr4SK9WxA=="], + + "@esbuild/linux-arm": ["@esbuild/linux-arm@0.25.10", "", { "os": "linux", "cpu": "arm" }, "sha512-oR31GtBTFYCqEBALI9r6WxoU/ZofZl962pouZRTEYECvNF/dtXKku8YXcJkhgK/beU+zedXfIzHijSRapJY3vg=="], + + "@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.25.10", "", { "os": "linux", "cpu": "arm64" }, "sha512-5luJWN6YKBsawd5f9i4+c+geYiVEw20FVW5x0v1kEMWNq8UctFjDiMATBxLvmmHA4bf7F6hTRaJgtghFr9iziQ=="], + + "@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.25.10", "", { "os": "linux", "cpu": "ia32" }, "sha512-NrSCx2Kim3EnnWgS4Txn0QGt0Xipoumb6z6sUtl5bOEZIVKhzfyp/Lyw4C1DIYvzeW/5mWYPBFJU3a/8Yr75DQ=="], + + "@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.25.10", "", { "os": "linux", "cpu": "none" }, "sha512-xoSphrd4AZda8+rUDDfD9J6FUMjrkTz8itpTITM4/xgerAZZcFW7Dv+sun7333IfKxGG8gAq+3NbfEMJfiY+Eg=="], + + "@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.25.10", "", { "os": "linux", "cpu": "none" }, "sha512-ab6eiuCwoMmYDyTnyptoKkVS3k8fy/1Uvq7Dj5czXI6DF2GqD2ToInBI0SHOp5/X1BdZ26RKc5+qjQNGRBelRA=="], + + "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.25.10", "", { "os": "linux", "cpu": "ppc64" }, "sha512-NLinzzOgZQsGpsTkEbdJTCanwA5/wozN9dSgEl12haXJBzMTpssebuXR42bthOF3z7zXFWH1AmvWunUCkBE4EA=="], + + "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.25.10", "", { "os": "linux", "cpu": "none" }, "sha512-FE557XdZDrtX8NMIeA8LBJX3dC2M8VGXwfrQWU7LB5SLOajfJIxmSdyL/gU1m64Zs9CBKvm4UAuBp5aJ8OgnrA=="], + + "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.25.10", "", { "os": "linux", "cpu": "s390x" }, "sha512-3BBSbgzuB9ajLoVZk0mGu+EHlBwkusRmeNYdqmznmMc9zGASFjSsxgkNsqmXugpPk00gJ0JNKh/97nxmjctdew=="], + + "@esbuild/linux-x64": ["@esbuild/linux-x64@0.25.10", "", { "os": "linux", "cpu": "x64" }, "sha512-QSX81KhFoZGwenVyPoberggdW1nrQZSvfVDAIUXr3WqLRZGZqWk/P4T8p2SP+de2Sr5HPcvjhcJzEiulKgnxtA=="], + + "@esbuild/netbsd-arm64": ["@esbuild/netbsd-arm64@0.25.10", "", { "os": "none", "cpu": "arm64" }, "sha512-AKQM3gfYfSW8XRk8DdMCzaLUFB15dTrZfnX8WXQoOUpUBQ+NaAFCP1kPS/ykbbGYz7rxn0WS48/81l9hFl3u4A=="], + + "@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.25.10", "", { "os": "none", "cpu": "x64" }, "sha512-7RTytDPGU6fek/hWuN9qQpeGPBZFfB4zZgcz2VK2Z5VpdUxEI8JKYsg3JfO0n/Z1E/6l05n0unDCNc4HnhQGig=="], + + "@esbuild/openbsd-arm64": ["@esbuild/openbsd-arm64@0.25.10", "", { "os": "openbsd", "cpu": "arm64" }, "sha512-5Se0VM9Wtq797YFn+dLimf2Zx6McttsH2olUBsDml+lm0GOCRVebRWUvDtkY4BWYv/3NgzS8b/UM3jQNh5hYyw=="], + + "@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.25.10", "", { "os": "openbsd", "cpu": "x64" }, "sha512-XkA4frq1TLj4bEMB+2HnI0+4RnjbuGZfet2gs/LNs5Hc7D89ZQBHQ0gL2ND6Lzu1+QVkjp3x1gIcPKzRNP8bXw=="], + + "@esbuild/openharmony-arm64": ["@esbuild/openharmony-arm64@0.25.10", "", { "os": "none", "cpu": "arm64" }, "sha512-AVTSBhTX8Y/Fz6OmIVBip9tJzZEUcY8WLh7I59+upa5/GPhh2/aM6bvOMQySspnCCHvFi79kMtdJS1w0DXAeag=="], + + "@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.25.10", "", { "os": "sunos", "cpu": "x64" }, "sha512-fswk3XT0Uf2pGJmOpDB7yknqhVkJQkAQOcW/ccVOtfx05LkbWOaRAtn5SaqXypeKQra1QaEa841PgrSL9ubSPQ=="], + + "@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.25.10", "", { "os": "win32", "cpu": "arm64" }, "sha512-ah+9b59KDTSfpaCg6VdJoOQvKjI33nTaQr4UluQwW7aEwZQsbMCfTmfEO4VyewOxx4RaDT/xCy9ra2GPWmO7Kw=="], + + "@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.25.10", "", { "os": "win32", "cpu": "ia32" }, "sha512-QHPDbKkrGO8/cz9LKVnJU22HOi4pxZnZhhA2HYHez5Pz4JeffhDjf85E57Oyco163GnzNCVkZK0b/n4Y0UHcSw=="], + + "@esbuild/win32-x64": ["@esbuild/win32-x64@0.25.10", "", { "os": "win32", "cpu": "x64" }, "sha512-9KpxSVFCu0iK1owoez6aC/s/EdUQLDN3adTxGCqxMVhrPDj6bt5dbrHDXUuq+Bs2vATFBBrQS5vdQ/Ed2P+nbw=="], + + "@eslint-community/eslint-utils": ["@eslint-community/eslint-utils@4.9.0", "", { "dependencies": { "eslint-visitor-keys": "^3.4.3" }, "peerDependencies": { "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" } }, "sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g=="], + + "@eslint-community/regexpp": ["@eslint-community/regexpp@4.12.1", "", {}, "sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ=="], + + "@eslint/config-array": ["@eslint/config-array@0.21.0", "", { "dependencies": { "@eslint/object-schema": "^2.1.6", "debug": "^4.3.1", "minimatch": "^3.1.2" } }, "sha512-ENIdc4iLu0d93HeYirvKmrzshzofPw6VkZRKQGe9Nv46ZnWUzcF1xV01dcvEg/1wXUR61OmmlSfyeyO7EvjLxQ=="], + + "@eslint/config-helpers": ["@eslint/config-helpers@0.3.1", "", {}, "sha512-xR93k9WhrDYpXHORXpxVL5oHj3Era7wo6k/Wd8/IsQNnZUTzkGS29lyn3nAT05v6ltUuTFVCCYDEGfy2Or/sPA=="], + + "@eslint/core": ["@eslint/core@0.15.2", "", { "dependencies": { "@types/json-schema": "^7.0.15" } }, "sha512-78Md3/Rrxh83gCxoUc0EiciuOHsIITzLy53m3d9UyiW8y9Dj2D29FeETqyKA+BRK76tnTp6RXWb3pCay8Oyomg=="], + + "@eslint/eslintrc": ["@eslint/eslintrc@3.3.1", "", { "dependencies": { "ajv": "^6.12.4", "debug": "^4.3.2", "espree": "^10.0.1", "globals": "^14.0.0", "ignore": "^5.2.0", "import-fresh": "^3.2.1", "js-yaml": "^4.1.0", "minimatch": "^3.1.2", "strip-json-comments": "^3.1.1" } }, "sha512-gtF186CXhIl1p4pJNGZw8Yc6RlshoePRvE0X91oPGb3vZ8pM3qOS9W9NGPat9LziaBV7XrJWGylNQXkGcnM3IQ=="], + + "@eslint/js": ["@eslint/js@9.36.0", "", {}, "sha512-uhCbYtYynH30iZErszX78U+nR3pJU3RHGQ57NXy5QupD4SBVwDeU8TNBy+MjMngc1UyIW9noKqsRqfjQTBU2dw=="], + + "@eslint/object-schema": ["@eslint/object-schema@2.1.6", "", {}, "sha512-RBMg5FRL0I0gs51M/guSAj5/e14VQ4tpZnQNWwuDT66P14I43ItmPfIZRhO9fUVIPOAQXU47atlywZ/czoqFPA=="], + + "@eslint/plugin-kit": ["@eslint/plugin-kit@0.3.5", "", { "dependencies": { "@eslint/core": "^0.15.2", "levn": "^0.4.1" } }, "sha512-Z5kJ+wU3oA7MMIqVR9tyZRtjYPr4OC004Q4Rw7pgOKUOKkJfZ3O24nz3WYfGRpMDNmcOi3TwQOmgm7B7Tpii0w=="], + + "@humanfs/core": ["@humanfs/core@0.19.1", "", {}, "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA=="], + + "@humanfs/node": ["@humanfs/node@0.16.7", "", { "dependencies": { "@humanfs/core": "^0.19.1", "@humanwhocodes/retry": "^0.4.0" } }, "sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ=="], + + "@humanwhocodes/module-importer": ["@humanwhocodes/module-importer@1.0.1", "", {}, "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA=="], + + "@humanwhocodes/retry": ["@humanwhocodes/retry@0.4.3", "", {}, "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ=="], + + "@inquirer/ansi": ["@inquirer/ansi@1.0.0", "", {}, "sha512-JWaTfCxI1eTmJ1BIv86vUfjVatOdxwD0DAVKYevY8SazeUUZtW+tNbsdejVO1GYE0GXJW1N1ahmiC3TFd+7wZA=="], + + "@inquirer/checkbox": ["@inquirer/checkbox@4.2.4", "", { "dependencies": { "@inquirer/ansi": "^1.0.0", "@inquirer/core": "^10.2.2", "@inquirer/figures": "^1.0.13", "@inquirer/type": "^3.0.8", "yoctocolors-cjs": "^2.1.2" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-2n9Vgf4HSciFq8ttKXk+qy+GsyTXPV1An6QAwe/8bkbbqvG4VW1I/ZY1pNu2rf+h9bdzMLPbRSfcNxkHBy/Ydw=="], + + "@inquirer/confirm": ["@inquirer/confirm@5.1.18", "", { "dependencies": { "@inquirer/core": "^10.2.2", "@inquirer/type": "^3.0.8" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-MilmWOzHa3Ks11tzvuAmFoAd/wRuaP3SwlT1IZhyMke31FKLxPiuDWcGXhU+PKveNOpAc4axzAgrgxuIJJRmLw=="], + + "@inquirer/core": ["@inquirer/core@10.2.2", "", { "dependencies": { "@inquirer/ansi": "^1.0.0", "@inquirer/figures": "^1.0.13", "@inquirer/type": "^3.0.8", "cli-width": "^4.1.0", "mute-stream": "^2.0.0", "signal-exit": "^4.1.0", "wrap-ansi": "^6.2.0", "yoctocolors-cjs": "^2.1.2" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-yXq/4QUnk4sHMtmbd7irwiepjB8jXU0kkFRL4nr/aDBA2mDz13cMakEWdDwX3eSCTkk03kwcndD1zfRAIlELxA=="], + + "@inquirer/editor": ["@inquirer/editor@4.2.20", "", { "dependencies": { "@inquirer/core": "^10.2.2", "@inquirer/external-editor": "^1.0.2", "@inquirer/type": "^3.0.8" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-7omh5y5bK672Q+Brk4HBbnHNowOZwrb/78IFXdrEB9PfdxL3GudQyDk8O9vQ188wj3xrEebS2M9n18BjJoI83g=="], + + "@inquirer/expand": ["@inquirer/expand@4.0.20", "", { "dependencies": { "@inquirer/core": "^10.2.2", "@inquirer/type": "^3.0.8", "yoctocolors-cjs": "^2.1.2" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-Dt9S+6qUg94fEvgn54F2Syf0Z3U8xmnBI9ATq2f5h9xt09fs2IJXSCIXyyVHwvggKWFXEY/7jATRo2K6Dkn6Ow=="], + + "@inquirer/external-editor": ["@inquirer/external-editor@1.0.2", "", { "dependencies": { "chardet": "^2.1.0", "iconv-lite": "^0.7.0" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-yy9cOoBnx58TlsPrIxauKIFQTiyH+0MK4e97y4sV9ERbI+zDxw7i2hxHLCIEGIE/8PPvDxGhgzIOTSOWcs6/MQ=="], + + "@inquirer/figures": ["@inquirer/figures@1.0.13", "", {}, "sha512-lGPVU3yO9ZNqA7vTYz26jny41lE7yoQansmqdMLBEfqaGsmdg7V3W9mK9Pvb5IL4EVZ9GnSDGMO/cJXud5dMaw=="], + + "@inquirer/input": ["@inquirer/input@4.2.4", "", { "dependencies": { "@inquirer/core": "^10.2.2", "@inquirer/type": "^3.0.8" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-cwSGpLBMwpwcZZsc6s1gThm0J+it/KIJ+1qFL2euLmSKUMGumJ5TcbMgxEjMjNHRGadouIYbiIgruKoDZk7klw=="], + + "@inquirer/number": ["@inquirer/number@3.0.20", "", { "dependencies": { "@inquirer/core": "^10.2.2", "@inquirer/type": "^3.0.8" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-bbooay64VD1Z6uMfNehED2A2YOPHSJnQLs9/4WNiV/EK+vXczf/R988itL2XLDGTgmhMF2KkiWZo+iEZmc4jqg=="], + + "@inquirer/password": ["@inquirer/password@4.0.20", "", { "dependencies": { "@inquirer/ansi": "^1.0.0", "@inquirer/core": "^10.2.2", "@inquirer/type": "^3.0.8" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-nxSaPV2cPvvoOmRygQR+h0B+Av73B01cqYLcr7NXcGXhbmsYfUb8fDdw2Us1bI2YsX+VvY7I7upgFYsyf8+Nug=="], + + "@inquirer/prompts": ["@inquirer/prompts@7.8.6", "", { "dependencies": { "@inquirer/checkbox": "^4.2.4", "@inquirer/confirm": "^5.1.18", "@inquirer/editor": "^4.2.20", "@inquirer/expand": "^4.0.20", "@inquirer/input": "^4.2.4", "@inquirer/number": "^3.0.20", "@inquirer/password": "^4.0.20", "@inquirer/rawlist": "^4.1.8", "@inquirer/search": "^3.1.3", "@inquirer/select": "^4.3.4" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-68JhkiojicX9SBUD8FE/pSKbOKtwoyaVj1kwqLfvjlVXZvOy3iaSWX4dCLsZyYx/5Ur07Fq+yuDNOen+5ce6ig=="], + + "@inquirer/rawlist": ["@inquirer/rawlist@4.1.8", "", { "dependencies": { "@inquirer/core": "^10.2.2", "@inquirer/type": "^3.0.8", "yoctocolors-cjs": "^2.1.2" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-CQ2VkIASbgI2PxdzlkeeieLRmniaUU1Aoi5ggEdm6BIyqopE9GuDXdDOj9XiwOqK5qm72oI2i6J+Gnjaa26ejg=="], + + "@inquirer/search": ["@inquirer/search@3.1.3", "", { "dependencies": { "@inquirer/core": "^10.2.2", "@inquirer/figures": "^1.0.13", "@inquirer/type": "^3.0.8", "yoctocolors-cjs": "^2.1.2" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-D5T6ioybJJH0IiSUK/JXcoRrrm8sXwzrVMjibuPs+AgxmogKslaafy1oxFiorNI4s3ElSkeQZbhYQgLqiL8h6Q=="], + + "@inquirer/select": ["@inquirer/select@4.3.4", "", { "dependencies": { "@inquirer/ansi": "^1.0.0", "@inquirer/core": "^10.2.2", "@inquirer/figures": "^1.0.13", "@inquirer/type": "^3.0.8", "yoctocolors-cjs": "^2.1.2" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-Qp20nySRmfbuJBBsgPU7E/cL62Hf250vMZRzYDcBHty2zdD1kKCnoDFWRr0WO2ZzaXp3R7a4esaVGJUx0E6zvA=="], + + "@inquirer/type": ["@inquirer/type@3.0.8", "", { "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-lg9Whz8onIHRthWaN1Q9EGLa/0LFJjyM8mEUbL1eTi6yMGvBf8gvyDLtxSXztQsxMvhxxNpJYrwa1YHdq+w4Jw=="], + + "@isaacs/cliui": ["@isaacs/cliui@8.0.2", "", { "dependencies": { "string-width": "^5.1.2", "string-width-cjs": "npm:string-width@^4.2.0", "strip-ansi": "^7.0.1", "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", "wrap-ansi": "^8.1.0", "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" } }, "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA=="], + + "@istanbuljs/schema": ["@istanbuljs/schema@0.1.3", "", {}, "sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA=="], + + "@jridgewell/gen-mapping": ["@jridgewell/gen-mapping@0.3.13", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.0", "@jridgewell/trace-mapping": "^0.3.24" } }, "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA=="], + + "@jridgewell/resolve-uri": ["@jridgewell/resolve-uri@3.1.2", "", {}, "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw=="], + + "@jridgewell/sourcemap-codec": ["@jridgewell/sourcemap-codec@1.5.5", "", {}, "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og=="], + + "@jridgewell/trace-mapping": ["@jridgewell/trace-mapping@0.3.31", "", { "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", "@jridgewell/sourcemap-codec": "^1.4.14" } }, "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw=="], + + "@ljharb/resumer": ["@ljharb/resumer@0.1.3", "", { "dependencies": { "@ljharb/through": "^2.3.13", "call-bind": "^1.0.7" } }, "sha512-d+tsDgfkj9X5QTriqM4lKesCkMMJC3IrbPKHvayP00ELx2axdXvDfWkqjxrLXIzGcQzmj7VAUT1wopqARTvafw=="], + + "@ljharb/through": ["@ljharb/through@2.3.14", "", { "dependencies": { "call-bind": "^1.0.8" } }, "sha512-ajBvlKpWucBB17FuQYUShqpqy8GRgYEpJW0vWJbUu1CV9lWyrDCapy0lScU8T8Z6qn49sSwJB3+M+evYIdGg+A=="], + + "@noble/hashes": ["@noble/hashes@2.0.1", "", {}, "sha512-XlOlEbQcE9fmuXxrVTXCTlG2nlRXa9Rj3rr5Ue/+tX+nmkgbX720YHh0VR3hBF9xDvwnb8D2shVGOwNx+ulArw=="], + + "@nodeutils/defaults-deep": ["@nodeutils/defaults-deep@1.1.0", "", { "dependencies": { "lodash": "^4.15.0" } }, "sha512-gG44cwQovaOFdSR02jR9IhVRpnDP64VN6JdjYJTfNz4J4fWn7TQnmrf22nSjRqlwlxPcW8PL/L3KbJg3tdwvpg=="], + + "@octokit/auth-token": ["@octokit/auth-token@6.0.0", "", {}, "sha512-P4YJBPdPSpWTQ1NU4XYdvHvXJJDxM6YwpS0FZHRgP7YFkdVxsWcpWGy/NVqlAA7PcPCnMacXlRm1y2PFZRWL/w=="], + + "@octokit/core": ["@octokit/core@7.0.4", "", { "dependencies": { "@octokit/auth-token": "^6.0.0", "@octokit/graphql": "^9.0.1", "@octokit/request": "^10.0.2", "@octokit/request-error": "^7.0.0", "@octokit/types": "^15.0.0", "before-after-hook": "^4.0.0", "universal-user-agent": "^7.0.0" } }, "sha512-jOT8V1Ba5BdC79sKrRWDdMT5l1R+XNHTPR6CPWzUP2EcfAcvIHZWF0eAbmRcpOOP5gVIwnqNg0C4nvh6Abc3OA=="], + + "@octokit/endpoint": ["@octokit/endpoint@11.0.0", "", { "dependencies": { "@octokit/types": "^14.0.0", "universal-user-agent": "^7.0.2" } }, "sha512-hoYicJZaqISMAI3JfaDr1qMNi48OctWuOih1m80bkYow/ayPw6Jj52tqWJ6GEoFTk1gBqfanSoI1iY99Z5+ekQ=="], + + "@octokit/graphql": ["@octokit/graphql@9.0.1", "", { "dependencies": { "@octokit/request": "^10.0.2", "@octokit/types": "^14.0.0", "universal-user-agent": "^7.0.0" } }, "sha512-j1nQNU1ZxNFx2ZtKmL4sMrs4egy5h65OMDmSbVyuCzjOcwsHq6EaYjOTGXPQxgfiN8dJ4CriYHk6zF050WEULg=="], + + "@octokit/openapi-types": ["@octokit/openapi-types@26.0.0", "", {}, "sha512-7AtcfKtpo77j7Ts73b4OWhOZHTKo/gGY8bB3bNBQz4H+GRSWqx2yvj8TXRsbdTE0eRmYmXOEY66jM7mJ7LzfsA=="], + + "@octokit/plugin-paginate-rest": ["@octokit/plugin-paginate-rest@13.1.1", "", { "dependencies": { "@octokit/types": "^14.1.0" }, "peerDependencies": { "@octokit/core": ">=6" } }, "sha512-q9iQGlZlxAVNRN2jDNskJW/Cafy7/XE52wjZ5TTvyhyOD904Cvx//DNyoO3J/MXJ0ve3rPoNWKEg5iZrisQSuw=="], + + "@octokit/plugin-request-log": ["@octokit/plugin-request-log@6.0.0", "", { "peerDependencies": { "@octokit/core": ">=6" } }, "sha512-UkOzeEN3W91/eBq9sPZNQ7sUBvYCqYbrrD8gTbBuGtHEuycE4/awMXcYvx6sVYo7LypPhmQwwpUe4Yyu4QZN5Q=="], + + "@octokit/plugin-rest-endpoint-methods": ["@octokit/plugin-rest-endpoint-methods@16.1.0", "", { "dependencies": { "@octokit/types": "^15.0.0" }, "peerDependencies": { "@octokit/core": ">=6" } }, "sha512-nCsyiKoGRnhH5LkH8hJEZb9swpqOcsW+VXv1QoyUNQXJeVODG4+xM6UICEqyqe9XFr6LkL8BIiFCPev8zMDXPw=="], + + "@octokit/request": ["@octokit/request@10.0.3", "", { "dependencies": { "@octokit/endpoint": "^11.0.0", "@octokit/request-error": "^7.0.0", "@octokit/types": "^14.0.0", "fast-content-type-parse": "^3.0.0", "universal-user-agent": "^7.0.2" } }, "sha512-V6jhKokg35vk098iBqp2FBKunk3kMTXlmq+PtbV9Gl3TfskWlebSofU9uunVKhUN7xl+0+i5vt0TGTG8/p/7HA=="], + + "@octokit/request-error": ["@octokit/request-error@7.0.0", "", { "dependencies": { "@octokit/types": "^14.0.0" } }, "sha512-KRA7VTGdVyJlh0cP5Tf94hTiYVVqmt2f3I6mnimmaVz4UG3gQV/k4mDJlJv3X67iX6rmN7gSHCF8ssqeMnmhZg=="], + + "@octokit/rest": ["@octokit/rest@22.0.0", "", { "dependencies": { "@octokit/core": "^7.0.2", "@octokit/plugin-paginate-rest": "^13.0.1", "@octokit/plugin-request-log": "^6.0.0", "@octokit/plugin-rest-endpoint-methods": "^16.0.0" } }, "sha512-z6tmTu9BTnw51jYGulxrlernpsQYXpui1RK21vmXn8yF5bp6iX16yfTtJYGK5Mh1qDkvDOmp2n8sRMcQmR8jiA=="], + + "@octokit/types": ["@octokit/types@15.0.0", "", { "dependencies": { "@octokit/openapi-types": "^26.0.0" } }, "sha512-8o6yDfmoGJUIeR9OfYU0/TUJTnMPG2r68+1yEdUeG2Fdqpj8Qetg0ziKIgcBm0RW/j29H41WP37CYCEhp6GoHQ=="], + + "@paralleldrive/cuid2": ["@paralleldrive/cuid2@3.1.0", "", { "dependencies": { "@noble/hashes": "^2.0.1", "bignumber.js": "^9.3.1", "error-causes": "^3.0.2" }, "bin": { "cuid2": "bin/cuid2.js" } }, "sha512-UhTJsF2XGlIFmGGTUKBfmNCX+B/UCv3w0OHhq2CJIsfH33GN1lkgjATozG+Pf7s3ACcUdM4qaWgzy4Rr8PlUdA=="], + + "@phun-ky/typeof": ["@phun-ky/typeof@2.0.3", "", {}, "sha512-oeQJs1aa8Ghke8JIK9yuq/+KjMiaYeDZ38jx7MhkXncXlUKjqQ3wEm2X3qCKyjo+ZZofZj+WsEEiqkTtRuE2xQ=="], + + "@pkgjs/parseargs": ["@pkgjs/parseargs@0.11.0", "", {}, "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg=="], + + "@pkgr/core": ["@pkgr/core@0.2.9", "", {}, "sha512-QNqXyfVS2wm9hweSYD2O7F0G06uurj9kZ96TRQE5Y9hU7+tgdZwIkbAKc5Ocy1HxEY2kuDQa6cQ1WRs/O5LFKA=="], + + "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.52.2", "", { "os": "android", "cpu": "arm" }, "sha512-o3pcKzJgSGt4d74lSZ+OCnHwkKBeAbFDmbEm5gg70eA8VkyCuC/zV9TwBnmw6VjDlRdF4Pshfb+WE9E6XY1PoQ=="], + + "@rollup/rollup-android-arm64": ["@rollup/rollup-android-arm64@4.52.2", "", { "os": "android", "cpu": "arm64" }, "sha512-cqFSWO5tX2vhC9hJTK8WAiPIm4Q8q/cU8j2HQA0L3E1uXvBYbOZMhE2oFL8n2pKB5sOCHY6bBuHaRwG7TkfJyw=="], + + "@rollup/rollup-darwin-arm64": ["@rollup/rollup-darwin-arm64@4.52.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-vngduywkkv8Fkh3wIZf5nFPXzWsNsVu1kvtLETWxTFf/5opZmflgVSeLgdHR56RQh71xhPhWoOkEBvbehwTlVA=="], + + "@rollup/rollup-darwin-x64": ["@rollup/rollup-darwin-x64@4.52.2", "", { "os": "darwin", "cpu": "x64" }, "sha512-h11KikYrUCYTrDj6h939hhMNlqU2fo/X4NB0OZcys3fya49o1hmFaczAiJWVAFgrM1NCP6RrO7lQKeVYSKBPSQ=="], + + "@rollup/rollup-freebsd-arm64": ["@rollup/rollup-freebsd-arm64@4.52.2", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-/eg4CI61ZUkLXxMHyVlmlGrSQZ34xqWlZNW43IAU4RmdzWEx0mQJ2mN/Cx4IHLVZFL6UBGAh+/GXhgvGb+nVxw=="], + + "@rollup/rollup-freebsd-x64": ["@rollup/rollup-freebsd-x64@4.52.2", "", { "os": "freebsd", "cpu": "x64" }, "sha512-QOWgFH5X9+p+S1NAfOqc0z8qEpJIoUHf7OWjNUGOeW18Mx22lAUOiA9b6r2/vpzLdfxi/f+VWsYjUOMCcYh0Ng=="], + + "@rollup/rollup-linux-arm-gnueabihf": ["@rollup/rollup-linux-arm-gnueabihf@4.52.2", "", { "os": "linux", "cpu": "arm" }, "sha512-kDWSPafToDd8LcBYd1t5jw7bD5Ojcu12S3uT372e5HKPzQt532vW+rGFFOaiR0opxePyUkHrwz8iWYEyH1IIQA=="], + + "@rollup/rollup-linux-arm-musleabihf": ["@rollup/rollup-linux-arm-musleabihf@4.52.2", "", { "os": "linux", "cpu": "arm" }, "sha512-gKm7Mk9wCv6/rkzwCiUC4KnevYhlf8ztBrDRT9g/u//1fZLapSRc+eDZj2Eu2wpJ+0RzUKgtNijnVIB4ZxyL+w=="], + + "@rollup/rollup-linux-arm64-gnu": ["@rollup/rollup-linux-arm64-gnu@4.52.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-66lA8vnj5mB/rtDNwPgrrKUOtCLVQypkyDa2gMfOefXK6rcZAxKLO9Fy3GkW8VkPnENv9hBkNOFfGLf6rNKGUg=="], + + "@rollup/rollup-linux-arm64-musl": ["@rollup/rollup-linux-arm64-musl@4.52.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-s+OPucLNdJHvuZHuIz2WwncJ+SfWHFEmlC5nKMUgAelUeBUnlB4wt7rXWiyG4Zn07uY2Dd+SGyVa9oyLkVGOjA=="], + + "@rollup/rollup-linux-loong64-gnu": ["@rollup/rollup-linux-loong64-gnu@4.52.2", "", { "os": "linux", "cpu": "none" }, "sha512-8wTRM3+gVMDLLDdaT6tKmOE3lJyRy9NpJUS/ZRWmLCmOPIJhVyXwjBo+XbrrwtV33Em1/eCTd5TuGJm4+DmYjw=="], + + "@rollup/rollup-linux-ppc64-gnu": ["@rollup/rollup-linux-ppc64-gnu@4.52.2", "", { "os": "linux", "cpu": "ppc64" }, "sha512-6yqEfgJ1anIeuP2P/zhtfBlDpXUb80t8DpbYwXQ3bQd95JMvUaqiX+fKqYqUwZXqdJDd8xdilNtsHM2N0cFm6A=="], + + "@rollup/rollup-linux-riscv64-gnu": ["@rollup/rollup-linux-riscv64-gnu@4.52.2", "", { "os": "linux", "cpu": "none" }, "sha512-sshYUiYVSEI2B6dp4jMncwxbrUqRdNApF2c3bhtLAU0qA8Lrri0p0NauOsTWh3yCCCDyBOjESHMExonp7Nzc0w=="], + + "@rollup/rollup-linux-riscv64-musl": ["@rollup/rollup-linux-riscv64-musl@4.52.2", "", { "os": "linux", "cpu": "none" }, "sha512-duBLgd+3pqC4MMwBrKkFxaZerUxZcYApQVC5SdbF5/e/589GwVvlRUnyqMFbM8iUSb1BaoX/3fRL7hB9m2Pj8Q=="], + + "@rollup/rollup-linux-s390x-gnu": ["@rollup/rollup-linux-s390x-gnu@4.52.2", "", { "os": "linux", "cpu": "s390x" }, "sha512-tzhYJJidDUVGMgVyE+PmxENPHlvvqm1KILjjZhB8/xHYqAGeizh3GBGf9u6WdJpZrz1aCpIIHG0LgJgH9rVjHQ=="], + + "@rollup/rollup-linux-x64-gnu": ["@rollup/rollup-linux-x64-gnu@4.52.2", "", { "os": "linux", "cpu": "x64" }, "sha512-opH8GSUuVcCSSyHHcl5hELrmnk4waZoVpgn/4FDao9iyE4WpQhyWJ5ryl5M3ocp4qkRuHfyXnGqg8M9oKCEKRA=="], + + "@rollup/rollup-linux-x64-musl": ["@rollup/rollup-linux-x64-musl@4.52.2", "", { "os": "linux", "cpu": "x64" }, "sha512-LSeBHnGli1pPKVJ79ZVJgeZWWZXkEe/5o8kcn23M8eMKCUANejchJbF/JqzM4RRjOJfNRhKJk8FuqL1GKjF5oQ=="], + + "@rollup/rollup-openharmony-arm64": ["@rollup/rollup-openharmony-arm64@4.52.2", "", { "os": "none", "cpu": "arm64" }, "sha512-uPj7MQ6/s+/GOpolavm6BPo+6CbhbKYyZHUDvZ/SmJM7pfDBgdGisFX3bY/CBDMg2ZO4utfhlApkSfZ92yXw7Q=="], + + "@rollup/rollup-win32-arm64-msvc": ["@rollup/rollup-win32-arm64-msvc@4.52.2", "", { "os": "win32", "cpu": "arm64" }, "sha512-Z9MUCrSgIaUeeHAiNkm3cQyst2UhzjPraR3gYYfOjAuZI7tcFRTOD+4cHLPoS/3qinchth+V56vtqz1Tv+6KPA=="], + + "@rollup/rollup-win32-ia32-msvc": ["@rollup/rollup-win32-ia32-msvc@4.52.2", "", { "os": "win32", "cpu": "ia32" }, "sha512-+GnYBmpjldD3XQd+HMejo+0gJGwYIOfFeoBQv32xF/RUIvccUz20/V6Otdv+57NE70D5pa8W/jVGDoGq0oON4A=="], + + "@rollup/rollup-win32-x64-gnu": ["@rollup/rollup-win32-x64-gnu@4.52.2", "", { "os": "win32", "cpu": "x64" }, "sha512-ApXFKluSB6kDQkAqZOKXBjiaqdF1BlKi+/eqnYe9Ee7U2K3pUDKsIyr8EYm/QDHTJIM+4X+lI0gJc3TTRhd+dA=="], + + "@rollup/rollup-win32-x64-msvc": ["@rollup/rollup-win32-x64-msvc@4.52.2", "", { "os": "win32", "cpu": "x64" }, "sha512-ARz+Bs8kY6FtitYM96PqPEVvPXqEZmPZsSkXvyX19YzDqkCaIlhCieLLMI5hxO9SRZ2XtCtm8wxhy0iJ2jxNfw=="], + + "@sinclair/typebox": ["@sinclair/typebox@0.34.41", "", {}, "sha512-6gS8pZzSXdyRHTIqoqSVknxolr1kzfy4/CeDnrzsVz8TTIWUbOBr6gnzOmTYJ3eXQNh4IYHIGi5aIL7sOZ2G/g=="], + + "@textlint/ast-node-types": ["@textlint/ast-node-types@12.6.1", "", {}, "sha512-uzlJ+ZsCAyJm+lBi7j0UeBbj+Oy6w/VWoGJ3iHRHE5eZ8Z4iK66mq+PG/spupmbllLtz77OJbY89BYqgFyjXmA=="], + + "@textlint/markdown-to-ast": ["@textlint/markdown-to-ast@12.6.1", "", { "dependencies": { "@textlint/ast-node-types": "^12.6.1", "debug": "^4.3.4", "mdast-util-gfm-autolink-literal": "^0.1.3", "remark-footnotes": "^3.0.0", "remark-frontmatter": "^3.0.0", "remark-gfm": "^1.0.0", "remark-parse": "^9.0.0", "traverse": "^0.6.7", "unified": "^9.2.2" } }, "sha512-T0HO+VrU9VbLRiEx/kH4+gwGMHNMIGkp0Pok+p0I33saOOLyhfGvwOKQgvt2qkxzQEV2L5MtGB8EnW4r5d3CqQ=="], + + "@tootallnate/quickjs-emscripten": ["@tootallnate/quickjs-emscripten@0.23.0", "", {}, "sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA=="], + + "@types/chai": ["@types/chai@5.2.2", "", { "dependencies": { "@types/deep-eql": "*" } }, "sha512-8kB30R7Hwqf40JPiKhVzodJs2Qc1ZJ5zuT3uzw5Hq/dhNCl3G3l83jfpdI1e20BP348+fV7VIL/+FxaXkqBmWg=="], + + "@types/deep-eql": ["@types/deep-eql@4.0.2", "", {}, "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw=="], + + "@types/estree": ["@types/estree@1.0.8", "", {}, "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w=="], + + "@types/json-schema": ["@types/json-schema@7.0.15", "", {}, "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA=="], + + "@types/mdast": ["@types/mdast@3.0.15", "", { "dependencies": { "@types/unist": "^2" } }, "sha512-LnwD+mUEfxWMa1QpDraczIn6k0Ee3SMicuYSSzS6ZYl2gKS09EClnJYGd8Du6rfc5r/GZEk5o1mRb8TaTj03sQ=="], + + "@types/parse-path": ["@types/parse-path@7.0.3", "", {}, "sha512-LriObC2+KYZD3FzCrgWGv/qufdUy4eXrxcLgQMfYXgPbLIecKIsVBaQgUPmxSSLcjmYbDTQbMgr6qr6l/eb7Bg=="], + + "@types/unist": ["@types/unist@2.0.11", "", {}, "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA=="], + + "@vitest/coverage-v8": ["@vitest/coverage-v8@3.2.4", "", { "dependencies": { "@ampproject/remapping": "^2.3.0", "@bcoe/v8-coverage": "^1.0.2", "ast-v8-to-istanbul": "^0.3.3", "debug": "^4.4.1", "istanbul-lib-coverage": "^3.2.2", "istanbul-lib-report": "^3.0.1", "istanbul-lib-source-maps": "^5.0.6", "istanbul-reports": "^3.1.7", "magic-string": "^0.30.17", "magicast": "^0.3.5", "std-env": "^3.9.0", "test-exclude": "^7.0.1", "tinyrainbow": "^2.0.0" }, "peerDependencies": { "@vitest/browser": "3.2.4", "vitest": "3.2.4" }, "optionalPeers": ["@vitest/browser"] }, "sha512-EyF9SXU6kS5Ku/U82E259WSnvg6c8KTjppUncuNdm5QHpe17mwREHnjDzozC8x9MZ0xfBUFSaLkRv4TMA75ALQ=="], + + "@vitest/expect": ["@vitest/expect@3.2.4", "", { "dependencies": { "@types/chai": "^5.2.2", "@vitest/spy": "3.2.4", "@vitest/utils": "3.2.4", "chai": "^5.2.0", "tinyrainbow": "^2.0.0" } }, "sha512-Io0yyORnB6sikFlt8QW5K7slY4OjqNX9jmJQ02QDda8lyM6B5oNgVWoSoKPac8/kgnCUzuHQKrSLtu/uOqqrig=="], + + "@vitest/mocker": ["@vitest/mocker@3.2.4", "", { "dependencies": { "@vitest/spy": "3.2.4", "estree-walker": "^3.0.3", "magic-string": "^0.30.17" }, "peerDependencies": { "msw": "^2.4.9", "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0" }, "optionalPeers": ["msw"] }, "sha512-46ryTE9RZO/rfDd7pEqFl7etuyzekzEhUbTW3BvmeO/BcCMEgq59BKhek3dXDWgAj4oMK6OZi+vRr1wPW6qjEQ=="], + + "@vitest/pretty-format": ["@vitest/pretty-format@3.2.4", "", { "dependencies": { "tinyrainbow": "^2.0.0" } }, "sha512-IVNZik8IVRJRTr9fxlitMKeJeXFFFN0JaB9PHPGQ8NKQbGpfjlTx9zO4RefN8gp7eqjNy8nyK3NZmBzOPeIxtA=="], + + "@vitest/runner": ["@vitest/runner@3.2.4", "", { "dependencies": { "@vitest/utils": "3.2.4", "pathe": "^2.0.3", "strip-literal": "^3.0.0" } }, "sha512-oukfKT9Mk41LreEW09vt45f8wx7DordoWUZMYdY/cyAk7w5TWkTRCNZYF7sX7n2wB7jyGAl74OxgwhPgKaqDMQ=="], + + "@vitest/snapshot": ["@vitest/snapshot@3.2.4", "", { "dependencies": { "@vitest/pretty-format": "3.2.4", "magic-string": "^0.30.17", "pathe": "^2.0.3" } }, "sha512-dEYtS7qQP2CjU27QBC5oUOxLE/v5eLkGqPE0ZKEIDGMs4vKWe7IjgLOeauHsR0D5YuuycGRO5oSRXnwnmA78fQ=="], + + "@vitest/spy": ["@vitest/spy@3.2.4", "", { "dependencies": { "tinyspy": "^4.0.3" } }, "sha512-vAfasCOe6AIK70iP5UD11Ac4siNUNJ9i/9PZ3NKx07sG6sUxeag1LWdNrMWeKKYBLlzuK+Gn65Yd5nyL6ds+nw=="], + + "@vitest/utils": ["@vitest/utils@3.2.4", "", { "dependencies": { "@vitest/pretty-format": "3.2.4", "loupe": "^3.1.4", "tinyrainbow": "^2.0.0" } }, "sha512-fB2V0JFrQSMsCo9HiSq3Ezpdv4iYaXRG1Sx8edX3MwxfyNn83mKiGzOcH+Fkxt4MHxr3y42fQi1oeAInqgX2QA=="], + + "acorn": ["acorn@8.15.0", "", { "bin": "bin/acorn" }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="], + + "acorn-jsx": ["acorn-jsx@5.3.2", "", { "peerDependencies": { "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" } }, "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ=="], + + "agent-base": ["agent-base@7.1.4", "", {}, "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ=="], + + "ajv": ["ajv@6.12.6", "", { "dependencies": { "fast-deep-equal": "^3.1.1", "fast-json-stable-stringify": "^2.0.0", "json-schema-traverse": "^0.4.1", "uri-js": "^4.2.2" } }, "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g=="], + + "anchor-markdown-header": ["anchor-markdown-header@0.6.0", "", { "dependencies": { "emoji-regex": "~10.1.0" } }, "sha512-v7HJMtE1X7wTpNFseRhxsY/pivP4uAJbidVhPT+yhz4i/vV1+qx371IXuV9V7bN6KjFtheLJxqaSm0Y/8neJTA=="], + + "ansi-regex": ["ansi-regex@6.2.2", "", {}, "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg=="], + + "ansi-styles": ["ansi-styles@4.3.0", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="], + + "argparse": ["argparse@2.0.1", "", {}, "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="], + + "array-buffer-byte-length": ["array-buffer-byte-length@1.0.2", "", { "dependencies": { "call-bound": "^1.0.3", "is-array-buffer": "^3.0.5" } }, "sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw=="], + + "array.prototype.every": ["array.prototype.every@1.1.7", "", { "dependencies": { "call-bound": "^1.0.2", "define-properties": "^1.2.1", "es-abstract": "^1.23.5", "es-object-atoms": "^1.0.0", "is-string": "^1.1.0" } }, "sha512-BIP72rKvrKd08ptbetLb4qvrlGjkv30yOKgKcTtOIbHyQt3shr/jyOzdApiCOh3LPYrpJo5M6i0zmVldOF2pUw=="], + + "arraybuffer.prototype.slice": ["arraybuffer.prototype.slice@1.0.4", "", { "dependencies": { "array-buffer-byte-length": "^1.0.1", "call-bind": "^1.0.8", "define-properties": "^1.2.1", "es-abstract": "^1.23.5", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.6", "is-array-buffer": "^3.0.4" } }, "sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ=="], + + "assertion-error": ["assertion-error@2.0.1", "", {}, "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA=="], + + "ast-types": ["ast-types@0.13.4", "", { "dependencies": { "tslib": "^2.0.1" } }, "sha512-x1FCFnFifvYDDzTaLII71vG5uvDwgtmDTEVWAxrgeiR8VjMONcCXJx7E+USjDtHlwFmt9MysbqgF9b9Vjr6w+w=="], + + "ast-v8-to-istanbul": ["ast-v8-to-istanbul@0.3.5", "", { "dependencies": { "@jridgewell/trace-mapping": "^0.3.30", "estree-walker": "^3.0.3", "js-tokens": "^9.0.1" } }, "sha512-9SdXjNheSiE8bALAQCQQuT6fgQaoxJh7IRYrRGZ8/9nv8WhJeC1aXAwN8TbaOssGOukUvyvnkgD9+Yuykvl1aA=="], + + "async-function": ["async-function@1.0.0", "", {}, "sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA=="], + + "async-retry": ["async-retry@1.3.3", "", { "dependencies": { "retry": "0.13.1" } }, "sha512-wfr/jstw9xNi/0teMHrRW7dsz3Lt5ARhYNZ2ewpadnhaIp5mbALhOAP+EAdsC7t4Z6wqsDVv9+W6gm1Dk9mEyw=="], + + "available-typed-arrays": ["available-typed-arrays@1.0.7", "", { "dependencies": { "possible-typed-array-names": "^1.0.0" } }, "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ=="], + + "bail": ["bail@1.0.5", "", {}, "sha512-xFbRxM1tahm08yHBP16MMjVUAvDaBMD38zsM9EMAUN61omwLmKlOpB/Zku5QkjZ8TZ4vn53pj+t518cH0S03RQ=="], + + "balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="], + + "base64-js": ["base64-js@1.5.1", "", {}, "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA=="], + + "basic-ftp": ["basic-ftp@5.0.5", "", {}, "sha512-4Bcg1P8xhUuqcii/S0Z9wiHIrQVPMermM1any+MX5GeGD7faD3/msQUDGLol9wOcz4/jbg/WJnGqoJF6LiBdtg=="], + + "before-after-hook": ["before-after-hook@4.0.0", "", {}, "sha512-q6tR3RPqIB1pMiTRMFcZwuG5T8vwp+vUvEG0vuI6B+Rikh5BfPp2fQ82c925FOs+b0lcFQ8CFrL+KbilfZFhOQ=="], + + "better-sqlite3": ["better-sqlite3@12.6.2", "", { "dependencies": { "bindings": "^1.5.0", "prebuild-install": "^7.1.1" } }, "sha512-8VYKM3MjCa9WcaSAI3hzwhmyHVlH8tiGFwf0RlTsZPWJ1I5MkzjiudCo4KC4DxOaL/53A5B1sI/IbldNFDbsKA=="], + + "bignumber.js": ["bignumber.js@9.3.1", "", {}, "sha512-Ko0uX15oIUS7wJ3Rb30Fs6SkVbLmPBAKdlm7q9+ak9bbIeFf0MwuBsQV6z7+X768/cHsfg+WlysDWJcmthjsjQ=="], + + "bindings": ["bindings@1.5.0", "", { "dependencies": { "file-uri-to-path": "1.0.0" } }, "sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ=="], + + "bl": ["bl@4.1.0", "", { "dependencies": { "buffer": "^5.5.0", "inherits": "^2.0.4", "readable-stream": "^3.4.0" } }, "sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w=="], + + "boolbase": ["boolbase@1.0.0", "", {}, "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww=="], + + "brace-expansion": ["brace-expansion@1.1.12", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg=="], + + "buffer": ["buffer@5.7.1", "", { "dependencies": { "base64-js": "^1.3.1", "ieee754": "^1.1.13" } }, "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ=="], + + "bundle-name": ["bundle-name@4.1.0", "", { "dependencies": { "run-applescript": "^7.0.0" } }, "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q=="], + + "c12": ["c12@3.3.0", "", { "dependencies": { "chokidar": "^4.0.3", "confbox": "^0.2.2", "defu": "^6.1.4", "dotenv": "^17.2.2", "exsolve": "^1.0.7", "giget": "^2.0.0", "jiti": "^2.5.1", "ohash": "^2.0.11", "pathe": "^2.0.3", "perfect-debounce": "^2.0.0", "pkg-types": "^2.3.0", "rc9": "^2.1.2" }, "peerDependencies": { "magicast": "^0.3.5" } }, "sha512-K9ZkuyeJQeqLEyqldbYLG3wjqwpw4BVaAqvmxq3GYKK0b1A/yYQdIcJxkzAOWcNVWhJpRXAPfZFueekiY/L8Dw=="], + + "cac": ["cac@6.7.14", "", {}, "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ=="], + + "call-bind": ["call-bind@1.0.8", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.0", "es-define-property": "^1.0.0", "get-intrinsic": "^1.2.4", "set-function-length": "^1.2.2" } }, "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww=="], + + "call-bind-apply-helpers": ["call-bind-apply-helpers@1.0.2", "", { "dependencies": { "es-errors": "^1.3.0", "function-bind": "^1.1.2" } }, "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ=="], + + "call-bound": ["call-bound@1.0.4", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "get-intrinsic": "^1.3.0" } }, "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg=="], + + "callsites": ["callsites@3.1.0", "", {}, "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ=="], + + "ccount": ["ccount@1.1.0", "", {}, "sha512-vlNK021QdI7PNeiUh/lKkC/mNHHfV0m/Ad5JoI0TYtlBnJAslM/JIkm/tGC88bkLIwO6OQ5uV6ztS6kVAtCDlg=="], + + "chai": ["chai@5.3.3", "", { "dependencies": { "assertion-error": "^2.0.1", "check-error": "^2.1.1", "deep-eql": "^5.0.1", "loupe": "^3.1.0", "pathval": "^2.0.0" } }, "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw=="], + + "chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="], + + "character-entities": ["character-entities@1.2.4", "", {}, "sha512-iBMyeEHxfVnIakwOuDXpVkc54HijNgCyQB2w0VfGQThle6NXn50zU6V/u+LDhxHcDUPojn6Kpga3PTAD8W1bQw=="], + + "character-entities-legacy": ["character-entities-legacy@1.1.4", "", {}, "sha512-3Xnr+7ZFS1uxeiUDvV02wQ+QDbc55o97tIV5zHScSPJpcLm/r0DFPcoY3tYRp+VZukxuMeKgXYmsXQHO05zQeA=="], + + "character-reference-invalid": ["character-reference-invalid@1.1.4", "", {}, "sha512-mKKUkUbhPpQlCOfIuZkvSEgktjPFIsZKRRbC6KWVEMvlzblj3i3asQv5ODsrwt0N3pHAEvjP8KTQPHkp0+6jOg=="], + + "chardet": ["chardet@2.1.0", "", {}, "sha512-bNFETTG/pM5ryzQ9Ad0lJOTa6HWD/YsScAR3EnCPZRPlQh77JocYktSHOUHelyhm8IARL+o4c4F1bP5KVOjiRA=="], + + "check-error": ["check-error@2.1.1", "", {}, "sha512-OAlb+T7V4Op9OwdkjmguYRqncdlx5JiofwOAUkmTF+jNdHwzTaTs4sRAGpzLF3oOz5xAyDGrPgeIDFQmDOTiJw=="], + + "cheerio": ["cheerio@1.1.2", "", { "dependencies": { "cheerio-select": "^2.1.0", "dom-serializer": "^2.0.0", "domhandler": "^5.0.3", "domutils": "^3.2.2", "encoding-sniffer": "^0.2.1", "htmlparser2": "^10.0.0", "parse5": "^7.3.0", "parse5-htmlparser2-tree-adapter": "^7.1.0", "parse5-parser-stream": "^7.1.2", "undici": "^7.12.0", "whatwg-mimetype": "^4.0.0" } }, "sha512-IkxPpb5rS/d1IiLbHMgfPuS0FgiWTtFIm/Nj+2woXDLTZ7fOT2eqzgYbdMlLweqlHbsZjxEChoVK+7iph7jyQg=="], + + "cheerio-select": ["cheerio-select@2.1.0", "", { "dependencies": { "boolbase": "^1.0.0", "css-select": "^5.1.0", "css-what": "^6.1.0", "domelementtype": "^2.3.0", "domhandler": "^5.0.3", "domutils": "^3.0.1" } }, "sha512-9v9kG0LvzrlcungtnJtpGNxY+fzECQKhK4EGJX2vByejiMX84MFNQw4UxPJl3bFbTMw+Dfs37XaIkCwTZfLh4g=="], + + "chokidar": ["chokidar@4.0.3", "", { "dependencies": { "readdirp": "^4.0.1" } }, "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA=="], + + "chownr": ["chownr@1.1.4", "", {}, "sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg=="], + + "ci-info": ["ci-info@4.3.0", "", {}, "sha512-l+2bNRMiQgcfILUi33labAZYIWlH1kWDp+ecNo5iisRKrbm0xcRyCww71/YU0Fkw0mAFpz9bJayXPjey6vkmaQ=="], + + "citty": ["citty@0.1.6", "", { "dependencies": { "consola": "^3.2.3" } }, "sha512-tskPPKEs8D2KPafUypv2gxwJP8h/OaJmC82QQGGDQcHvXX43xF2VDACcJVmZ0EuSxkpO9Kc4MlrA3q0+FG58AQ=="], + + "cli-cursor": ["cli-cursor@5.0.0", "", { "dependencies": { "restore-cursor": "^5.0.0" } }, "sha512-aCj4O5wKyszjMmDT4tZj93kxyydN/K5zPWSCe6/0AV/AA1pqe5ZBIw0a2ZfPQV7lL5/yb5HsUreJ6UFAF1tEQw=="], + + "cli-spinners": ["cli-spinners@3.3.0", "", {}, "sha512-/+40ljC3ONVnYIttjMWrlL51nItDAbBrq2upN8BPyvGU/2n5Oxw3tbNwORCaNuNqLJnxGqOfjUuhsv7l5Q4IsQ=="], + + "cli-width": ["cli-width@4.1.0", "", {}, "sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ=="], + + "color-convert": ["color-convert@2.0.1", "", { "dependencies": { "color-name": "~1.1.4" } }, "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="], + + "color-name": ["color-name@1.1.4", "", {}, "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="], + + "commander": ["commander@11.1.0", "", {}, "sha512-yPVavfyCcRhmorC7rWlkHn15b4wDVgVmBA7kV4QVBsF7kv/9TKJAbAXVTxvTnwP8HHKjRCJDClKbciiYS7p0DQ=="], + + "concat-map": ["concat-map@0.0.1", "", {}, "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg=="], + + "confbox": ["confbox@0.2.2", "", {}, "sha512-1NB+BKqhtNipMsov4xI/NnhCKp9XG9NamYp5PVm9klAT0fsrNPjaFICsCFhNhwZJKNh7zB/3q8qXz0E9oaMNtQ=="], + + "consola": ["consola@3.4.2", "", {}, "sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA=="], + + "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="], + + "css-select": ["css-select@5.2.2", "", { "dependencies": { "boolbase": "^1.0.0", "css-what": "^6.1.0", "domhandler": "^5.0.2", "domutils": "^3.0.1", "nth-check": "^2.0.1" } }, "sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw=="], + + "css-what": ["css-what@6.2.2", "", {}, "sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA=="], + + "data-uri-to-buffer": ["data-uri-to-buffer@6.0.2", "", {}, "sha512-7hvf7/GW8e86rW0ptuwS3OcBGDjIi6SZva7hCyWC0yYry2cOPmLIjXAUHI6DK2HsnwJd9ifmt57i8eV2n4YNpw=="], + + "data-view-buffer": ["data-view-buffer@1.0.2", "", { "dependencies": { "call-bound": "^1.0.3", "es-errors": "^1.3.0", "is-data-view": "^1.0.2" } }, "sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ=="], + + "data-view-byte-length": ["data-view-byte-length@1.0.2", "", { "dependencies": { "call-bound": "^1.0.3", "es-errors": "^1.3.0", "is-data-view": "^1.0.2" } }, "sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ=="], + + "data-view-byte-offset": ["data-view-byte-offset@1.0.1", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "is-data-view": "^1.0.1" } }, "sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ=="], + + "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="], + + "decompress-response": ["decompress-response@6.0.0", "", { "dependencies": { "mimic-response": "^3.1.0" } }, "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ=="], + + "deep-eql": ["deep-eql@5.0.2", "", {}, "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q=="], + + "deep-equal": ["deep-equal@2.2.3", "", { "dependencies": { "array-buffer-byte-length": "^1.0.0", "call-bind": "^1.0.5", "es-get-iterator": "^1.1.3", "get-intrinsic": "^1.2.2", "is-arguments": "^1.1.1", "is-array-buffer": "^3.0.2", "is-date-object": "^1.0.5", "is-regex": "^1.1.4", "is-shared-array-buffer": "^1.0.2", "isarray": "^2.0.5", "object-is": "^1.1.5", "object-keys": "^1.1.1", "object.assign": "^4.1.4", "regexp.prototype.flags": "^1.5.1", "side-channel": "^1.0.4", "which-boxed-primitive": "^1.0.2", "which-collection": "^1.0.1", "which-typed-array": "^1.1.13" } }, "sha512-ZIwpnevOurS8bpT4192sqAowWM76JDKSHYzMLty3BZGSswgq6pBaH3DhCSW5xVAZICZyKdOBPjwww5wfgT/6PA=="], + + "deep-extend": ["deep-extend@0.6.0", "", {}, "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA=="], + + "deep-is": ["deep-is@0.1.4", "", {}, "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ=="], + + "default-browser": ["default-browser@5.2.1", "", { "dependencies": { "bundle-name": "^4.1.0", "default-browser-id": "^5.0.0" } }, "sha512-WY/3TUME0x3KPYdRRxEJJvXRHV4PyPoUsxtZa78lwItwRQRHhd2U9xOscaT/YTf8uCXIAjeJOFBVEh/7FtD8Xg=="], + + "default-browser-id": ["default-browser-id@5.0.0", "", {}, "sha512-A6p/pu/6fyBcA1TRz/GqWYPViplrftcW2gZC9q79ngNCKAeR/X3gcEdXQHl4KNXV+3wgIJ1CPkJQ3IHM6lcsyA=="], + + "define-data-property": ["define-data-property@1.1.4", "", { "dependencies": { "es-define-property": "^1.0.0", "es-errors": "^1.3.0", "gopd": "^1.0.1" } }, "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A=="], + + "define-lazy-prop": ["define-lazy-prop@3.0.0", "", {}, "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg=="], + + "define-properties": ["define-properties@1.2.1", "", { "dependencies": { "define-data-property": "^1.0.1", "has-property-descriptors": "^1.0.0", "object-keys": "^1.1.1" } }, "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg=="], + + "defined": ["defined@1.0.1", "", {}, "sha512-hsBd2qSVCRE+5PmNdHt1uzyrFu5d3RwmFDKzyNZMFq/EwDNJF7Ee5+D5oEKF0hU6LhtoUF1macFvOe4AskQC1Q=="], + + "defu": ["defu@6.1.4", "", {}, "sha512-mEQCMmwJu317oSz8CwdIOdwf3xMif1ttiM8LTufzc3g6kR+9Pe236twL8j3IYT1F7GfRgGcW6MWxzZjLIkuHIg=="], + + "degenerator": ["degenerator@5.0.1", "", { "dependencies": { "ast-types": "^0.13.4", "escodegen": "^2.1.0", "esprima": "^4.0.1" } }, "sha512-TllpMR/t0M5sqCXfj85i4XaAzxmS5tVA16dqvdkMwGmzI+dXLXnw3J+3Vdv7VKw+ThlTMboK6i9rnZ6Nntj5CQ=="], + + "destr": ["destr@2.0.5", "", {}, "sha512-ugFTXCtDZunbzasqBxrK93Ik/DRYsO6S/fedkWEMKqt04xZ4csmnmwGDBAb07QWNaGMAmnTIemsYZCksjATwsA=="], + + "detect-libc": ["detect-libc@2.1.2", "", {}, "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ=="], + + "doctoc": ["doctoc@2.2.1", "", { "dependencies": { "@textlint/markdown-to-ast": "^12.1.1", "anchor-markdown-header": "^0.6.0", "htmlparser2": "^7.2.0", "minimist": "^1.2.6", "underscore": "^1.13.2", "update-section": "^0.3.3" }, "bin": "doctoc.js" }, "sha512-qNJ1gsuo7hH40vlXTVVrADm6pdg30bns/Mo7Nv1SxuXSM1bwF9b4xQ40a6EFT/L1cI+Yylbyi8MPI4G4y7XJzQ=="], + + "dom-serializer": ["dom-serializer@2.0.0", "", { "dependencies": { "domelementtype": "^2.3.0", "domhandler": "^5.0.2", "entities": "^4.2.0" } }, "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg=="], + + "domelementtype": ["domelementtype@2.3.0", "", {}, "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw=="], + + "domhandler": ["domhandler@4.3.1", "", { "dependencies": { "domelementtype": "^2.2.0" } }, "sha512-GrwoxYN+uWlzO8uhUXRl0P+kHE4GtVPfYzVLcUxPL7KNdHKj66vvlhiweIHqYYXWlw+T8iLMp42Lm67ghw4WMQ=="], + + "domutils": ["domutils@2.8.0", "", { "dependencies": { "dom-serializer": "^1.0.1", "domelementtype": "^2.2.0", "domhandler": "^4.2.0" } }, "sha512-w96Cjofp72M5IIhpjgobBimYEfoPjx1Vx0BSX9P30WBdZW2WIKU0T1Bd0kz2eNZ9ikjKgHbEyKx8BB6H1L3h3A=="], + + "dotenv": ["dotenv@17.2.2", "", {}, "sha512-Sf2LSQP+bOlhKWWyhFsn0UsfdK/kCWRv1iuA2gXAwt3dyNabr6QSj00I2V10pidqz69soatm9ZwZvpQMTIOd5Q=="], + + "dotignore": ["dotignore@0.1.2", "", { "dependencies": { "minimatch": "^3.0.4" }, "bin": { "ignored": "bin/ignored" } }, "sha512-UGGGWfSauusaVJC+8fgV+NVvBXkCTmVv7sk6nojDZZvuOUNGUy0Zk4UpHQD6EDjS0jpBwcACvH4eofvyzBcRDw=="], + + "dunder-proto": ["dunder-proto@1.0.1", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.1", "es-errors": "^1.3.0", "gopd": "^1.2.0" } }, "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A=="], + + "eastasianwidth": ["eastasianwidth@0.2.0", "", {}, "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA=="], + + "emoji-regex": ["emoji-regex@10.1.0", "", {}, "sha512-xAEnNCT3w2Tg6MA7ly6QqYJvEoY1tm9iIjJ3yMKK9JPlWuRHAMoe5iETwQnx3M9TVbFMfsrBgWKR+IsmswwNjg=="], + + "encoding-sniffer": ["encoding-sniffer@0.2.1", "", { "dependencies": { "iconv-lite": "^0.6.3", "whatwg-encoding": "^3.1.1" } }, "sha512-5gvq20T6vfpekVtqrYQsSCFZ1wEg5+wW0/QaZMWkFr6BqD3NfKs0rLCx4rrVlSWJeZb5NBJgVLswK/w2MWU+Gw=="], + + "end-of-stream": ["end-of-stream@1.4.5", "", { "dependencies": { "once": "^1.4.0" } }, "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg=="], + + "entities": ["entities@3.0.1", "", {}, "sha512-WiyBqoomrwMdFG1e0kqvASYfnlb0lp8M5o5Fw2OFq1hNZxxcNk8Ik0Xm7LxzBhuidnZB/UtBqVCgUz3kBOP51Q=="], + + "error-causes": ["error-causes@3.0.2", "", {}, "sha512-i0B8zq1dHL6mM85FGoxaJnVtx6LD5nL2v0hlpGdntg5FOSyzQ46c9lmz5qx0xRS2+PWHGOHcYxGIBC5Le2dRMw=="], + + "es-abstract": ["es-abstract@1.24.0", "", { "dependencies": { "array-buffer-byte-length": "^1.0.2", "arraybuffer.prototype.slice": "^1.0.4", "available-typed-arrays": "^1.0.7", "call-bind": "^1.0.8", "call-bound": "^1.0.4", "data-view-buffer": "^1.0.2", "data-view-byte-length": "^1.0.2", "data-view-byte-offset": "^1.0.1", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "es-set-tostringtag": "^2.1.0", "es-to-primitive": "^1.3.0", "function.prototype.name": "^1.1.8", "get-intrinsic": "^1.3.0", "get-proto": "^1.0.1", "get-symbol-description": "^1.1.0", "globalthis": "^1.0.4", "gopd": "^1.2.0", "has-property-descriptors": "^1.0.2", "has-proto": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "internal-slot": "^1.1.0", "is-array-buffer": "^3.0.5", "is-callable": "^1.2.7", "is-data-view": "^1.0.2", "is-negative-zero": "^2.0.3", "is-regex": "^1.2.1", "is-set": "^2.0.3", "is-shared-array-buffer": "^1.0.4", "is-string": "^1.1.1", "is-typed-array": "^1.1.15", "is-weakref": "^1.1.1", "math-intrinsics": "^1.1.0", "object-inspect": "^1.13.4", "object-keys": "^1.1.1", "object.assign": "^4.1.7", "own-keys": "^1.0.1", "regexp.prototype.flags": "^1.5.4", "safe-array-concat": "^1.1.3", "safe-push-apply": "^1.0.0", "safe-regex-test": "^1.1.0", "set-proto": "^1.0.0", "stop-iteration-iterator": "^1.1.0", "string.prototype.trim": "^1.2.10", "string.prototype.trimend": "^1.0.9", "string.prototype.trimstart": "^1.0.8", "typed-array-buffer": "^1.0.3", "typed-array-byte-length": "^1.0.3", "typed-array-byte-offset": "^1.0.4", "typed-array-length": "^1.0.7", "unbox-primitive": "^1.1.0", "which-typed-array": "^1.1.19" } }, "sha512-WSzPgsdLtTcQwm4CROfS5ju2Wa1QQcVeT37jFjYzdFz1r9ahadC8B8/a4qxJxM+09F18iumCdRmlr96ZYkQvEg=="], + + "es-define-property": ["es-define-property@1.0.1", "", {}, "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g=="], + + "es-errors": ["es-errors@1.3.0", "", {}, "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="], + + "es-get-iterator": ["es-get-iterator@1.1.3", "", { "dependencies": { "call-bind": "^1.0.2", "get-intrinsic": "^1.1.3", "has-symbols": "^1.0.3", "is-arguments": "^1.1.1", "is-map": "^2.0.2", "is-set": "^2.0.2", "is-string": "^1.0.7", "isarray": "^2.0.5", "stop-iteration-iterator": "^1.0.0" } }, "sha512-sPZmqHBe6JIiTfN5q2pEi//TwxmAFHwj/XEuYjTuse78i8KxaqMTTzxPoFKuzRpDpTJ+0NAbpfenkmH2rePtuw=="], + + "es-module-lexer": ["es-module-lexer@1.7.0", "", {}, "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA=="], + + "es-object-atoms": ["es-object-atoms@1.1.1", "", { "dependencies": { "es-errors": "^1.3.0" } }, "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA=="], + + "es-set-tostringtag": ["es-set-tostringtag@2.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "get-intrinsic": "^1.2.6", "has-tostringtag": "^1.0.2", "hasown": "^2.0.2" } }, "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA=="], + + "es-to-primitive": ["es-to-primitive@1.3.0", "", { "dependencies": { "is-callable": "^1.2.7", "is-date-object": "^1.0.5", "is-symbol": "^1.0.4" } }, "sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g=="], + + "esbuild": ["esbuild@0.25.10", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.25.10", "@esbuild/android-arm": "0.25.10", "@esbuild/android-arm64": "0.25.10", "@esbuild/android-x64": "0.25.10", "@esbuild/darwin-arm64": "0.25.10", "@esbuild/darwin-x64": "0.25.10", "@esbuild/freebsd-arm64": "0.25.10", "@esbuild/freebsd-x64": "0.25.10", "@esbuild/linux-arm": "0.25.10", "@esbuild/linux-arm64": "0.25.10", "@esbuild/linux-ia32": "0.25.10", "@esbuild/linux-loong64": "0.25.10", "@esbuild/linux-mips64el": "0.25.10", "@esbuild/linux-ppc64": "0.25.10", "@esbuild/linux-riscv64": "0.25.10", "@esbuild/linux-s390x": "0.25.10", "@esbuild/linux-x64": "0.25.10", "@esbuild/netbsd-arm64": "0.25.10", "@esbuild/netbsd-x64": "0.25.10", "@esbuild/openbsd-arm64": "0.25.10", "@esbuild/openbsd-x64": "0.25.10", "@esbuild/openharmony-arm64": "0.25.10", "@esbuild/sunos-x64": "0.25.10", "@esbuild/win32-arm64": "0.25.10", "@esbuild/win32-ia32": "0.25.10", "@esbuild/win32-x64": "0.25.10" }, "bin": "bin/esbuild" }, "sha512-9RiGKvCwaqxO2owP61uQ4BgNborAQskMR6QusfWzQqv7AZOg5oGehdY2pRJMTKuwxd1IDBP4rSbI5lHzU7SMsQ=="], + + "escape-string-regexp": ["escape-string-regexp@4.0.0", "", {}, "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA=="], + + "escodegen": ["escodegen@2.1.0", "", { "dependencies": { "esprima": "^4.0.1", "estraverse": "^5.2.0", "esutils": "^2.0.2" }, "optionalDependencies": { "source-map": "~0.6.1" }, "bin": { "escodegen": "bin/escodegen.js", "esgenerate": "bin/esgenerate.js" } }, "sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w=="], + + "eslint": ["eslint@9.36.0", "", { "dependencies": { "@eslint-community/eslint-utils": "^4.8.0", "@eslint-community/regexpp": "^4.12.1", "@eslint/config-array": "^0.21.0", "@eslint/config-helpers": "^0.3.1", "@eslint/core": "^0.15.2", "@eslint/eslintrc": "^3.3.1", "@eslint/js": "9.36.0", "@eslint/plugin-kit": "^0.3.5", "@humanfs/node": "^0.16.6", "@humanwhocodes/module-importer": "^1.0.1", "@humanwhocodes/retry": "^0.4.2", "@types/estree": "^1.0.6", "@types/json-schema": "^7.0.15", "ajv": "^6.12.4", "chalk": "^4.0.0", "cross-spawn": "^7.0.6", "debug": "^4.3.2", "escape-string-regexp": "^4.0.0", "eslint-scope": "^8.4.0", "eslint-visitor-keys": "^4.2.1", "espree": "^10.4.0", "esquery": "^1.5.0", "esutils": "^2.0.2", "fast-deep-equal": "^3.1.3", "file-entry-cache": "^8.0.0", "find-up": "^5.0.0", "glob-parent": "^6.0.2", "ignore": "^5.2.0", "imurmurhash": "^0.1.4", "is-glob": "^4.0.0", "json-stable-stringify-without-jsonify": "^1.0.1", "lodash.merge": "^4.6.2", "minimatch": "^3.1.2", "natural-compare": "^1.4.0", "optionator": "^0.9.3" }, "peerDependencies": { "jiti": "*" }, "bin": "bin/eslint.js" }, "sha512-hB4FIzXovouYzwzECDcUkJ4OcfOEkXTv2zRY6B9bkwjx/cprAq0uvm1nl7zvQ0/TsUk0zQiN4uPfJpB9m+rPMQ=="], + + "eslint-config-prettier": ["eslint-config-prettier@10.1.8", "", { "peerDependencies": { "eslint": ">=7.0.0" }, "bin": "bin/cli.js" }, "sha512-82GZUjRS0p/jganf6q1rEO25VSoHH0hKPCTrgillPjdI/3bgBhAE1QzHrHTizjpRvy6pGAvKjDJtk2pF9NDq8w=="], + + "eslint-plugin-prettier": ["eslint-plugin-prettier@5.5.4", "", { "dependencies": { "prettier-linter-helpers": "^1.0.0", "synckit": "^0.11.7" }, "peerDependencies": { "@types/eslint": ">=8.0.0", "eslint": ">=8.0.0", "eslint-config-prettier": ">= 7.0.0 <10.0.0 || >=10.1.0", "prettier": ">=3.0.0" }, "optionalPeers": ["@types/eslint"] }, "sha512-swNtI95SToIz05YINMA6Ox5R057IMAmWZ26GqPxusAp1TZzj+IdY9tXNWWD3vkF/wEqydCONcwjTFpxybBqZsg=="], + + "eslint-scope": ["eslint-scope@8.4.0", "", { "dependencies": { "esrecurse": "^4.3.0", "estraverse": "^5.2.0" } }, "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg=="], + + "eslint-visitor-keys": ["eslint-visitor-keys@4.2.1", "", {}, "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ=="], + + "esm": ["esm@3.2.25", "", {}, "sha512-U1suiZ2oDVWv4zPO56S0NcR5QriEahGtdN2OR6FiOG4WJvcjBVFB0qI4+eKoWFH483PKGuLuu6V8Z4T5g63UVA=="], + + "espree": ["espree@10.4.0", "", { "dependencies": { "acorn": "^8.15.0", "acorn-jsx": "^5.3.2", "eslint-visitor-keys": "^4.2.1" } }, "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ=="], + + "esprima": ["esprima@4.0.1", "", { "bin": { "esparse": "bin/esparse.js", "esvalidate": "bin/esvalidate.js" } }, "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A=="], + + "esquery": ["esquery@1.6.0", "", { "dependencies": { "estraverse": "^5.1.0" } }, "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg=="], + + "esrecurse": ["esrecurse@4.3.0", "", { "dependencies": { "estraverse": "^5.2.0" } }, "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag=="], + + "estraverse": ["estraverse@5.3.0", "", {}, "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA=="], + + "estree-walker": ["estree-walker@3.0.3", "", { "dependencies": { "@types/estree": "^1.0.0" } }, "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g=="], + + "esutils": ["esutils@2.0.3", "", {}, "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g=="], + + "eta": ["eta@4.0.1", "", {}, "sha512-0h0oBEsF6qAJU7eu9ztvJoTo8D2PAq/4FvXVIQA1fek3WOTe6KPsVJycekG1+g1N6mfpblkheoGwaUhMtnlH4A=="], + + "execa": ["execa@8.0.1", "", { "dependencies": { "cross-spawn": "^7.0.3", "get-stream": "^8.0.1", "human-signals": "^5.0.0", "is-stream": "^3.0.0", "merge-stream": "^2.0.0", "npm-run-path": "^5.1.0", "onetime": "^6.0.0", "signal-exit": "^4.1.0", "strip-final-newline": "^3.0.0" } }, "sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg=="], + + "expand-template": ["expand-template@2.0.3", "", {}, "sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg=="], + + "expect-type": ["expect-type@1.2.2", "", {}, "sha512-JhFGDVJ7tmDJItKhYgJCGLOWjuK9vPxiXoUFLwLDc99NlmklilbiQJwoctZtt13+xMw91MCk/REan6MWHqDjyA=="], + + "exsolve": ["exsolve@1.0.7", "", {}, "sha512-VO5fQUzZtI6C+vx4w/4BWJpg3s/5l+6pRQEHzFRM8WFi4XffSP1Z+4qi7GbjWbvRQEbdIco5mIMq+zX4rPuLrw=="], + + "extend": ["extend@3.0.2", "", {}, "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g=="], + + "extend-shallow": ["extend-shallow@2.0.1", "", { "dependencies": { "is-extendable": "^0.1.0" } }, "sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug=="], + + "fast-content-type-parse": ["fast-content-type-parse@3.0.0", "", {}, "sha512-ZvLdcY8P+N8mGQJahJV5G4U88CSvT1rP8ApL6uETe88MBXrBHAkZlSEySdUlyztF7ccb+Znos3TFqaepHxdhBg=="], + + "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="], + + "fast-diff": ["fast-diff@1.3.0", "", {}, "sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw=="], + + "fast-json-stable-stringify": ["fast-json-stable-stringify@2.1.0", "", {}, "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw=="], + + "fast-levenshtein": ["fast-levenshtein@2.0.6", "", {}, "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw=="], + + "fault": ["fault@1.0.4", "", { "dependencies": { "format": "^0.2.0" } }, "sha512-CJ0HCB5tL5fYTEA7ToAq5+kTwd++Borf1/bifxd9iT70QcXr4MRrO3Llf8Ifs70q+SJcGHFtnIE/Nw6giCtECA=="], + + "fdir": ["fdir@6.5.0", "", { "peerDependencies": { "picomatch": "^3 || ^4" } }, "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg=="], + + "file-entry-cache": ["file-entry-cache@8.0.0", "", { "dependencies": { "flat-cache": "^4.0.0" } }, "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ=="], + + "file-uri-to-path": ["file-uri-to-path@1.0.0", "", {}, "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw=="], + + "find-up": ["find-up@5.0.0", "", { "dependencies": { "locate-path": "^6.0.0", "path-exists": "^4.0.0" } }, "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng=="], + + "flat-cache": ["flat-cache@4.0.1", "", { "dependencies": { "flatted": "^3.2.9", "keyv": "^4.5.4" } }, "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw=="], + + "flatted": ["flatted@3.3.3", "", {}, "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg=="], + + "for-each": ["for-each@0.3.5", "", { "dependencies": { "is-callable": "^1.2.7" } }, "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg=="], + + "foreground-child": ["foreground-child@3.3.1", "", { "dependencies": { "cross-spawn": "^7.0.6", "signal-exit": "^4.0.1" } }, "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw=="], + + "format": ["format@0.2.2", "", {}, "sha512-wzsgA6WOq+09wrU1tsJ09udeR/YZRaeArL9e1wPbFg3GG2yDnC2ldKpxs4xunpFF9DgqCqOIra3bc1HWrJ37Ww=="], + + "fs-constants": ["fs-constants@1.0.0", "", {}, "sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow=="], + + "fs-extra": ["fs-extra@11.3.2", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-Xr9F6z6up6Ws+NjzMCZc6WXg2YFRlrLP9NQDO3VQrWrfiojdhS56TzueT88ze0uBdCTwEIhQ3ptnmKeWGFAe0A=="], + + "fs.realpath": ["fs.realpath@1.0.0", "", {}, "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw=="], + + "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="], + + "function-bind": ["function-bind@1.1.2", "", {}, "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="], + + "function.prototype.name": ["function.prototype.name@1.1.8", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.3", "define-properties": "^1.2.1", "functions-have-names": "^1.2.3", "hasown": "^2.0.2", "is-callable": "^1.2.7" } }, "sha512-e5iwyodOHhbMr/yNrc7fDYG4qlbIvI5gajyzPnb5TCwyhjApznQh1BMFou9b30SevY43gCJKXycoCBjMbsuW0Q=="], + + "functions-have-names": ["functions-have-names@1.2.3", "", {}, "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ=="], + + "get-east-asian-width": ["get-east-asian-width@1.4.0", "", {}, "sha512-QZjmEOC+IT1uk6Rx0sX22V6uHWVwbdbxf1faPqJ1QhLdGgsRGCZoyaQBm/piRdJy/D2um6hM1UP7ZEeQ4EkP+Q=="], + + "get-intrinsic": ["get-intrinsic@1.3.0", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "function-bind": "^1.1.2", "get-proto": "^1.0.1", "gopd": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "math-intrinsics": "^1.1.0" } }, "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ=="], + + "get-package-type": ["get-package-type@0.1.0", "", {}, "sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q=="], + + "get-proto": ["get-proto@1.0.1", "", { "dependencies": { "dunder-proto": "^1.0.1", "es-object-atoms": "^1.0.0" } }, "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g=="], + + "get-stream": ["get-stream@8.0.1", "", {}, "sha512-VaUJspBffn/LMCJVoMvSAdmscJyS1auj5Zulnn5UoYcY531UWmdwhRWkcGKnGU93m5HSXP9LP2usOryrBtQowA=="], + + "get-symbol-description": ["get-symbol-description@1.1.0", "", { "dependencies": { "call-bound": "^1.0.3", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.6" } }, "sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg=="], + + "get-uri": ["get-uri@6.0.5", "", { "dependencies": { "basic-ftp": "^5.0.2", "data-uri-to-buffer": "^6.0.2", "debug": "^4.3.4" } }, "sha512-b1O07XYq8eRuVzBNgJLstU6FYc1tS6wnMtF1I1D9lE8LxZSOGZ7LhxN54yPP6mGw5f2CkXY2BQUL9Fx41qvcIg=="], + + "giget": ["giget@2.0.0", "", { "dependencies": { "citty": "^0.1.6", "consola": "^3.4.0", "defu": "^6.1.4", "node-fetch-native": "^1.6.6", "nypm": "^0.6.0", "pathe": "^2.0.3" }, "bin": "dist/cli.mjs" }, "sha512-L5bGsVkxJbJgdnwyuheIunkGatUF/zssUoxxjACCseZYAVbaqdh9Tsmmlkl8vYan09H7sbvKt4pS8GqKLBrEzA=="], + + "git-up": ["git-up@8.1.1", "", { "dependencies": { "is-ssh": "^1.4.0", "parse-url": "^9.2.0" } }, "sha512-FDenSF3fVqBYSaJoYy1KSc2wosx0gCvKP+c+PRBht7cAaiCeQlBtfBDX9vgnNOHmdePlSFITVcn4pFfcgNvx3g=="], + + "git-url-parse": ["git-url-parse@16.1.0", "", { "dependencies": { "git-up": "^8.1.0" } }, "sha512-cPLz4HuK86wClEW7iDdeAKcCVlWXmrLpb2L+G9goW0Z1dtpNS6BXXSOckUTlJT/LDQViE1QZKstNORzHsLnobw=="], + + "github-from-package": ["github-from-package@0.0.0", "", {}, "sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw=="], + + "glob": ["glob@10.4.5", "", { "dependencies": { "foreground-child": "^3.1.0", "jackspeak": "^3.1.2", "minimatch": "^9.0.4", "minipass": "^7.1.2", "package-json-from-dist": "^1.0.0", "path-scurry": "^1.11.1" }, "bin": "dist/esm/bin.mjs" }, "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg=="], + + "glob-parent": ["glob-parent@6.0.2", "", { "dependencies": { "is-glob": "^4.0.3" } }, "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A=="], + + "globals": ["globals@14.0.0", "", {}, "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ=="], + + "globalthis": ["globalthis@1.0.4", "", { "dependencies": { "define-properties": "^1.2.1", "gopd": "^1.0.1" } }, "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ=="], + + "gopd": ["gopd@1.2.0", "", {}, "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="], + + "graceful-fs": ["graceful-fs@4.2.11", "", {}, "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="], + + "gray-matter": ["gray-matter@4.0.3", "", { "dependencies": { "js-yaml": "^3.13.1", "kind-of": "^6.0.2", "section-matter": "^1.0.0", "strip-bom-string": "^1.0.0" } }, "sha512-5v6yZd4JK3eMI3FqqCouswVqwugaA9r4dNZB1wwcmrD02QkV5H0y7XBQW8QwQqEaZY1pM9aqORSORhJRdNK44Q=="], + + "has-bigints": ["has-bigints@1.1.0", "", {}, "sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg=="], + + "has-dynamic-import": ["has-dynamic-import@2.1.1", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.3", "get-intrinsic": "^1.2.6" } }, "sha512-DuTCn6K/RW8S27npDMumGKsjG6HE7MxzedZka5tJP+9dqfxks+UMqKBmeCijHtIhsBEZPlbMg0qMHi2nKYVtKQ=="], + + "has-flag": ["has-flag@4.0.0", "", {}, "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="], + + "has-property-descriptors": ["has-property-descriptors@1.0.2", "", { "dependencies": { "es-define-property": "^1.0.0" } }, "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg=="], + + "has-proto": ["has-proto@1.2.0", "", { "dependencies": { "dunder-proto": "^1.0.0" } }, "sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ=="], + + "has-symbols": ["has-symbols@1.1.0", "", {}, "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="], + + "has-tostringtag": ["has-tostringtag@1.0.2", "", { "dependencies": { "has-symbols": "^1.0.3" } }, "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw=="], + + "hasown": ["hasown@2.0.2", "", { "dependencies": { "function-bind": "^1.1.2" } }, "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ=="], + + "html-escaper": ["html-escaper@2.0.2", "", {}, "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg=="], + + "htmlparser2": ["htmlparser2@7.2.0", "", { "dependencies": { "domelementtype": "^2.0.1", "domhandler": "^4.2.2", "domutils": "^2.8.0", "entities": "^3.0.1" } }, "sha512-H7MImA4MS6cw7nbyURtLPO1Tms7C5H602LRETv95z1MxO/7CP7rDVROehUYeYBUYEON94NXXDEPmZuq+hX4sog=="], + + "http-proxy-agent": ["http-proxy-agent@7.0.2", "", { "dependencies": { "agent-base": "^7.1.0", "debug": "^4.3.4" } }, "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig=="], + + "https-proxy-agent": ["https-proxy-agent@7.0.6", "", { "dependencies": { "agent-base": "^7.1.2", "debug": "4" } }, "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw=="], + + "human-signals": ["human-signals@5.0.0", "", {}, "sha512-AXcZb6vzzrFAUE61HnN4mpLqd/cSIwNQjtNWR0euPm6y0iqx3G4gOXaIDdtdDwZmhwe82LA6+zinmW4UBWVePQ=="], + + "husky": ["husky@9.1.7", "", { "bin": "bin.js" }, "sha512-5gs5ytaNjBrh5Ow3zrvdUUY+0VxIuWVL4i9irt6friV+BqdCfmV11CQTWMiBYWHbXhco+J1kHfTOUkePhCDvMA=="], + + "iconv-lite": ["iconv-lite@0.6.3", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw=="], + + "ieee754": ["ieee754@1.2.1", "", {}, "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA=="], + + "ignore": ["ignore@5.3.2", "", {}, "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g=="], + + "import-fresh": ["import-fresh@3.3.1", "", { "dependencies": { "parent-module": "^1.0.0", "resolve-from": "^4.0.0" } }, "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ=="], + + "imurmurhash": ["imurmurhash@0.1.4", "", {}, "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA=="], + + "inflight": ["inflight@1.0.6", "", { "dependencies": { "once": "^1.3.0", "wrappy": "1" } }, "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA=="], + + "inherits": ["inherits@2.0.4", "", {}, "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="], + + "ini": ["ini@1.3.8", "", {}, "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew=="], + + "inquirer": ["inquirer@12.9.6", "", { "dependencies": { "@inquirer/ansi": "^1.0.0", "@inquirer/core": "^10.2.2", "@inquirer/prompts": "^7.8.6", "@inquirer/type": "^3.0.8", "mute-stream": "^2.0.0", "run-async": "^4.0.5", "rxjs": "^7.8.2" }, "peerDependencies": { "@types/node": ">=18" }, "optionalPeers": ["@types/node"] }, "sha512-603xXOgyfxhuis4nfnWaZrMaotNT0Km9XwwBNWUKbIDqeCY89jGr2F9YPEMiNhU6XjIP4VoWISMBFfcc5NgrTw=="], + + "internal-slot": ["internal-slot@1.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "hasown": "^2.0.2", "side-channel": "^1.1.0" } }, "sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw=="], + + "ip-address": ["ip-address@10.0.1", "", {}, "sha512-NWv9YLW4PoW2B7xtzaS3NCot75m6nK7Icdv0o3lfMceJVRfSoQwqD4wEH5rLwoKJwUiZ/rfpiVBhnaF0FK4HoA=="], + + "is-alphabetical": ["is-alphabetical@1.0.4", "", {}, "sha512-DwzsA04LQ10FHTZuL0/grVDk4rFoVH1pjAToYwBrHSxcrBIGQuXrQMtD5U1b0U2XVgKZCTLLP8u2Qxqhy3l2Vg=="], + + "is-alphanumerical": ["is-alphanumerical@1.0.4", "", { "dependencies": { "is-alphabetical": "^1.0.0", "is-decimal": "^1.0.0" } }, "sha512-UzoZUr+XfVz3t3v4KyGEniVL9BDRoQtY7tOyrRybkVNjDFWyo1yhXNGrrBTQxp3ib9BLAWs7k2YKBQsFRkZG9A=="], + + "is-arguments": ["is-arguments@1.2.0", "", { "dependencies": { "call-bound": "^1.0.2", "has-tostringtag": "^1.0.2" } }, "sha512-7bVbi0huj/wrIAOzb8U1aszg9kdi3KN/CyU19CTI7tAoZYEZoL9yCDXpbXN+uPsuWnP02cyug1gleqq+TU+YCA=="], + + "is-array-buffer": ["is-array-buffer@3.0.5", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.3", "get-intrinsic": "^1.2.6" } }, "sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A=="], + + "is-async-function": ["is-async-function@2.1.1", "", { "dependencies": { "async-function": "^1.0.0", "call-bound": "^1.0.3", "get-proto": "^1.0.1", "has-tostringtag": "^1.0.2", "safe-regex-test": "^1.1.0" } }, "sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ=="], + + "is-bigint": ["is-bigint@1.1.0", "", { "dependencies": { "has-bigints": "^1.0.2" } }, "sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ=="], + + "is-boolean-object": ["is-boolean-object@1.2.2", "", { "dependencies": { "call-bound": "^1.0.3", "has-tostringtag": "^1.0.2" } }, "sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A=="], + + "is-buffer": ["is-buffer@2.0.5", "", {}, "sha512-i2R6zNFDwgEHJyQUtJEk0XFi1i0dPFn/oqjK3/vPCcDeJvW5NQ83V8QbicfF1SupOaB0h8ntgBC2YiE7dfyctQ=="], + + "is-callable": ["is-callable@1.2.7", "", {}, "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA=="], + + "is-core-module": ["is-core-module@2.16.1", "", { "dependencies": { "hasown": "^2.0.2" } }, "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w=="], + + "is-data-view": ["is-data-view@1.0.2", "", { "dependencies": { "call-bound": "^1.0.2", "get-intrinsic": "^1.2.6", "is-typed-array": "^1.1.13" } }, "sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw=="], + + "is-date-object": ["is-date-object@1.1.0", "", { "dependencies": { "call-bound": "^1.0.2", "has-tostringtag": "^1.0.2" } }, "sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg=="], + + "is-decimal": ["is-decimal@1.0.4", "", {}, "sha512-RGdriMmQQvZ2aqaQq3awNA6dCGtKpiDFcOzrTWrDAT2MiWrKQVPmxLGHl7Y2nNu6led0kEyoX0enY0qXYsv9zw=="], + + "is-docker": ["is-docker@3.0.0", "", { "bin": "cli.js" }, "sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ=="], + + "is-extendable": ["is-extendable@0.1.1", "", {}, "sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw=="], + + "is-extglob": ["is-extglob@2.1.1", "", {}, "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ=="], + + "is-finalizationregistry": ["is-finalizationregistry@1.1.1", "", { "dependencies": { "call-bound": "^1.0.3" } }, "sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg=="], + + "is-fullwidth-code-point": ["is-fullwidth-code-point@3.0.0", "", {}, "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="], + + "is-generator-function": ["is-generator-function@1.1.0", "", { "dependencies": { "call-bound": "^1.0.3", "get-proto": "^1.0.0", "has-tostringtag": "^1.0.2", "safe-regex-test": "^1.1.0" } }, "sha512-nPUB5km40q9e8UfN/Zc24eLlzdSf9OfKByBw9CIdw4H1giPMeA0OIJvbchsCu4npfI2QcMVBsGEBHKZ7wLTWmQ=="], + + "is-glob": ["is-glob@4.0.3", "", { "dependencies": { "is-extglob": "^2.1.1" } }, "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg=="], + + "is-hexadecimal": ["is-hexadecimal@1.0.4", "", {}, "sha512-gyPJuv83bHMpocVYoqof5VDiZveEoGoFL8m3BXNb2VW8Xs+rz9kqO8LOQ5DH6EsuvilT1ApazU0pyl+ytbPtlw=="], + + "is-inside-container": ["is-inside-container@1.0.0", "", { "dependencies": { "is-docker": "^3.0.0" }, "bin": "cli.js" }, "sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA=="], + + "is-interactive": ["is-interactive@2.0.0", "", {}, "sha512-qP1vozQRI+BMOPcjFzrjXuQvdak2pHNUMZoeG2eRbiSqyvbEf/wQtEOTOX1guk6E3t36RkaqiSt8A/6YElNxLQ=="], + + "is-map": ["is-map@2.0.3", "", {}, "sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw=="], + + "is-negative-zero": ["is-negative-zero@2.0.3", "", {}, "sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw=="], + + "is-number-object": ["is-number-object@1.1.1", "", { "dependencies": { "call-bound": "^1.0.3", "has-tostringtag": "^1.0.2" } }, "sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw=="], + + "is-plain-obj": ["is-plain-obj@2.1.0", "", {}, "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA=="], + + "is-regex": ["is-regex@1.2.1", "", { "dependencies": { "call-bound": "^1.0.2", "gopd": "^1.2.0", "has-tostringtag": "^1.0.2", "hasown": "^2.0.2" } }, "sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g=="], + + "is-set": ["is-set@2.0.3", "", {}, "sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg=="], + + "is-shared-array-buffer": ["is-shared-array-buffer@1.0.4", "", { "dependencies": { "call-bound": "^1.0.3" } }, "sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A=="], + + "is-ssh": ["is-ssh@1.4.1", "", { "dependencies": { "protocols": "^2.0.1" } }, "sha512-JNeu1wQsHjyHgn9NcWTaXq6zWSR6hqE0++zhfZlkFBbScNkyvxCdeV8sRkSBaeLKxmbpR21brail63ACNxJ0Tg=="], + + "is-stream": ["is-stream@3.0.0", "", {}, "sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA=="], + + "is-string": ["is-string@1.1.1", "", { "dependencies": { "call-bound": "^1.0.3", "has-tostringtag": "^1.0.2" } }, "sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA=="], + + "is-symbol": ["is-symbol@1.1.1", "", { "dependencies": { "call-bound": "^1.0.2", "has-symbols": "^1.1.0", "safe-regex-test": "^1.1.0" } }, "sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w=="], + + "is-typed-array": ["is-typed-array@1.1.15", "", { "dependencies": { "which-typed-array": "^1.1.16" } }, "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ=="], + + "is-unicode-supported": ["is-unicode-supported@2.1.0", "", {}, "sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ=="], + + "is-weakmap": ["is-weakmap@2.0.2", "", {}, "sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w=="], + + "is-weakref": ["is-weakref@1.1.1", "", { "dependencies": { "call-bound": "^1.0.3" } }, "sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew=="], + + "is-weakset": ["is-weakset@2.0.4", "", { "dependencies": { "call-bound": "^1.0.3", "get-intrinsic": "^1.2.6" } }, "sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ=="], + + "is-wsl": ["is-wsl@3.1.0", "", { "dependencies": { "is-inside-container": "^1.0.0" } }, "sha512-UcVfVfaK4Sc4m7X3dUSoHoozQGBEFeDC+zVo06t98xe8CzHSZZBekNXH+tu0NalHolcJ/QAGqS46Hef7QXBIMw=="], + + "isarray": ["isarray@2.0.5", "", {}, "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw=="], + + "isexe": ["isexe@2.0.0", "", {}, "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="], + + "issue-parser": ["issue-parser@7.0.1", "", { "dependencies": { "lodash.capitalize": "^4.2.1", "lodash.escaperegexp": "^4.1.2", "lodash.isplainobject": "^4.0.6", "lodash.isstring": "^4.0.1", "lodash.uniqby": "^4.7.0" } }, "sha512-3YZcUUR2Wt1WsapF+S/WiA2WmlW0cWAoPccMqne7AxEBhCdFeTPjfv/Axb8V2gyCgY3nRw+ksZ3xSUX+R47iAg=="], + + "istanbul-lib-coverage": ["istanbul-lib-coverage@3.2.2", "", {}, "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg=="], + + "istanbul-lib-report": ["istanbul-lib-report@3.0.1", "", { "dependencies": { "istanbul-lib-coverage": "^3.0.0", "make-dir": "^4.0.0", "supports-color": "^7.1.0" } }, "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw=="], + + "istanbul-lib-source-maps": ["istanbul-lib-source-maps@5.0.6", "", { "dependencies": { "@jridgewell/trace-mapping": "^0.3.23", "debug": "^4.1.1", "istanbul-lib-coverage": "^3.0.0" } }, "sha512-yg2d+Em4KizZC5niWhQaIomgf5WlL4vOOjZ5xGCmF8SnPE/mDWWXgvRExdcpCgh9lLRRa1/fSYp2ymmbJ1pI+A=="], + + "istanbul-reports": ["istanbul-reports@3.2.0", "", { "dependencies": { "html-escaper": "^2.0.0", "istanbul-lib-report": "^3.0.0" } }, "sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA=="], + + "jackspeak": ["jackspeak@3.4.3", "", { "dependencies": { "@isaacs/cliui": "^8.0.2" }, "optionalDependencies": { "@pkgjs/parseargs": "^0.11.0" } }, "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw=="], + + "jiti": ["jiti@2.6.0", "", { "bin": "lib/jiti-cli.mjs" }, "sha512-VXe6RjJkBPj0ohtqaO8vSWP3ZhAKo66fKrFNCll4BTcwljPLz03pCbaNKfzGP5MbrCYcbJ7v0nOYYwUzTEIdXQ=="], + + "js-sha3": ["js-sha3@0.9.3", "", {}, "sha512-BcJPCQeLg6WjEx3FE591wVAevlli8lxsxm9/FzV4HXkV49TmBH38Yvrpce6fjbADGMKFrBMGTqrVz3qPIZ88Gg=="], + + "js-tokens": ["js-tokens@9.0.1", "", {}, "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ=="], + + "js-yaml": ["js-yaml@4.1.0", "", { "dependencies": { "argparse": "^2.0.1" }, "bin": "bin/js-yaml.js" }, "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA=="], + + "json-buffer": ["json-buffer@3.0.1", "", {}, "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ=="], + + "json-schema-traverse": ["json-schema-traverse@0.4.1", "", {}, "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="], + + "json-stable-stringify-without-jsonify": ["json-stable-stringify-without-jsonify@1.0.1", "", {}, "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw=="], + + "jsonfile": ["jsonfile@6.2.0", "", { "dependencies": { "universalify": "^2.0.0" }, "optionalDependencies": { "graceful-fs": "^4.1.6" } }, "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg=="], + + "keyv": ["keyv@4.5.4", "", { "dependencies": { "json-buffer": "3.0.1" } }, "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw=="], + + "kind-of": ["kind-of@6.0.3", "", {}, "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw=="], + + "levn": ["levn@0.4.1", "", { "dependencies": { "prelude-ls": "^1.2.1", "type-check": "~0.4.0" } }, "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ=="], + + "locate-path": ["locate-path@6.0.0", "", { "dependencies": { "p-locate": "^5.0.0" } }, "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw=="], + + "lodash": ["lodash@4.17.21", "", {}, "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg=="], + + "lodash.capitalize": ["lodash.capitalize@4.2.1", "", {}, "sha512-kZzYOKspf8XVX5AvmQF94gQW0lejFVgb80G85bU4ZWzoJ6C03PQg3coYAUpSTpQWelrZELd3XWgHzw4Ck5kaIw=="], + + "lodash.escaperegexp": ["lodash.escaperegexp@4.1.2", "", {}, "sha512-TM9YBvyC84ZxE3rgfefxUWiQKLilstD6k7PTGt6wfbtXF8ixIJLOL3VYyV/z+ZiPLsVxAsKAFVwWlWeb2Y8Yyw=="], + + "lodash.isplainobject": ["lodash.isplainobject@4.0.6", "", {}, "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA=="], + + "lodash.isstring": ["lodash.isstring@4.0.1", "", {}, "sha512-0wJxfxH1wgO3GrbuP+dTTk7op+6L41QCXbGINEmD+ny/G/eCqGzxyCsh7159S+mgDDcoarnBw6PC1PS5+wUGgw=="], + + "lodash.merge": ["lodash.merge@4.6.2", "", {}, "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ=="], + + "lodash.uniqby": ["lodash.uniqby@4.7.0", "", {}, "sha512-e/zcLx6CSbmaEgFHCA7BnoQKyCtKMxnuWrJygbwPs/AIn+IMKl66L8/s+wBUn5LRw2pZx3bUHibiV1b6aTWIww=="], + + "log-symbols": ["log-symbols@7.0.1", "", { "dependencies": { "is-unicode-supported": "^2.0.0", "yoctocolors": "^2.1.1" } }, "sha512-ja1E3yCr9i/0hmBVaM0bfwDjnGy8I/s6PP4DFp+yP+a+mrHO4Rm7DtmnqROTUkHIkqffC84YY7AeqX6oFk0WFg=="], + + "longest-streak": ["longest-streak@2.0.4", "", {}, "sha512-vM6rUVCVUJJt33bnmHiZEvr7wPT78ztX7rojL+LW51bHtLh6HTjx84LA5W4+oa6aKEJA7jJu5LR6vQRBpA5DVg=="], + + "loupe": ["loupe@3.2.1", "", {}, "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ=="], + + "lru-cache": ["lru-cache@7.18.3", "", {}, "sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA=="], + + "macos-release": ["macos-release@3.4.0", "", {}, "sha512-wpGPwyg/xrSp4H4Db4xYSeAr6+cFQGHfspHzDUdYxswDnUW0L5Ov63UuJiSr8NMSpyaChO4u1n0MXUvVPtrN6A=="], + + "magic-string": ["magic-string@0.30.19", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.5" } }, "sha512-2N21sPY9Ws53PZvsEpVtNuSW+ScYbQdp4b9qUaL+9QkHUrGFKo56Lg9Emg5s9V/qrtNBmiR01sYhUOwu3H+VOw=="], + + "magicast": ["magicast@0.3.5", "", { "dependencies": { "@babel/parser": "^7.25.4", "@babel/types": "^7.25.4", "source-map-js": "^1.2.0" } }, "sha512-L0WhttDl+2BOsybvEOLK7fW3UA0OQ0IQ2d6Zl2x/a6vVRs3bAY0ECOSHHeL5jD+SbOpOCUEi0y1DgHEn9Qn1AQ=="], + + "make-dir": ["make-dir@4.0.0", "", { "dependencies": { "semver": "^7.5.3" } }, "sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw=="], + + "markdown-table": ["markdown-table@2.0.0", "", { "dependencies": { "repeat-string": "^1.0.0" } }, "sha512-Ezda85ToJUBhM6WGaG6veasyym+Tbs3cMAw/ZhOPqXiYsr0jgocBV3j3nx+4lk47plLlIqjwuTm/ywVI+zjJ/A=="], + + "math-intrinsics": ["math-intrinsics@1.1.0", "", {}, "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="], + + "mdast-util-find-and-replace": ["mdast-util-find-and-replace@1.1.1", "", { "dependencies": { "escape-string-regexp": "^4.0.0", "unist-util-is": "^4.0.0", "unist-util-visit-parents": "^3.0.0" } }, "sha512-9cKl33Y21lyckGzpSmEQnIDjEfeeWelN5s1kUW1LwdB0Fkuq2u+4GdqcGEygYxJE8GVqCl0741bYXHgamfWAZA=="], + + "mdast-util-footnote": ["mdast-util-footnote@0.1.7", "", { "dependencies": { "mdast-util-to-markdown": "^0.6.0", "micromark": "~2.11.0" } }, "sha512-QxNdO8qSxqbO2e3m09KwDKfWiLgqyCurdWTQ198NpbZ2hxntdc+VKS4fDJCmNWbAroUdYnSthu+XbZ8ovh8C3w=="], + + "mdast-util-from-markdown": ["mdast-util-from-markdown@0.8.5", "", { "dependencies": { "@types/mdast": "^3.0.0", "mdast-util-to-string": "^2.0.0", "micromark": "~2.11.0", "parse-entities": "^2.0.0", "unist-util-stringify-position": "^2.0.0" } }, "sha512-2hkTXtYYnr+NubD/g6KGBS/0mFmBcifAsI0yIWRiRo0PjVs6SSOSOdtzbp6kSGnShDN6G5aWZpKQ2lWRy27mWQ=="], + + "mdast-util-frontmatter": ["mdast-util-frontmatter@0.2.0", "", { "dependencies": { "micromark-extension-frontmatter": "^0.2.0" } }, "sha512-FHKL4w4S5fdt1KjJCwB0178WJ0evnyyQr5kXTM3wrOVpytD0hrkvd+AOOjU9Td8onOejCkmZ+HQRT3CZ3coHHQ=="], + + "mdast-util-gfm": ["mdast-util-gfm@0.1.2", "", { "dependencies": { "mdast-util-gfm-autolink-literal": "^0.1.0", "mdast-util-gfm-strikethrough": "^0.2.0", "mdast-util-gfm-table": "^0.1.0", "mdast-util-gfm-task-list-item": "^0.1.0", "mdast-util-to-markdown": "^0.6.1" } }, "sha512-NNkhDx/qYcuOWB7xHUGWZYVXvjPFFd6afg6/e2g+SV4r9q5XUcCbV4Wfa3DLYIiD+xAEZc6K4MGaE/m0KDcPwQ=="], + + "mdast-util-gfm-autolink-literal": ["mdast-util-gfm-autolink-literal@0.1.3", "", { "dependencies": { "ccount": "^1.0.0", "mdast-util-find-and-replace": "^1.1.0", "micromark": "^2.11.3" } }, "sha512-GjmLjWrXg1wqMIO9+ZsRik/s7PLwTaeCHVB7vRxUwLntZc8mzmTsLVr6HW1yLokcnhfURsn5zmSVdi3/xWWu1A=="], + + "mdast-util-gfm-strikethrough": ["mdast-util-gfm-strikethrough@0.2.3", "", { "dependencies": { "mdast-util-to-markdown": "^0.6.0" } }, "sha512-5OQLXpt6qdbttcDG/UxYY7Yjj3e8P7X16LzvpX8pIQPYJ/C2Z1qFGMmcw+1PZMUM3Z8wt8NRfYTvCni93mgsgA=="], + + "mdast-util-gfm-table": ["mdast-util-gfm-table@0.1.6", "", { "dependencies": { "markdown-table": "^2.0.0", "mdast-util-to-markdown": "~0.6.0" } }, "sha512-j4yDxQ66AJSBwGkbpFEp9uG/LS1tZV3P33fN1gkyRB2LoRL+RR3f76m0HPHaby6F4Z5xr9Fv1URmATlRRUIpRQ=="], + + "mdast-util-gfm-task-list-item": ["mdast-util-gfm-task-list-item@0.1.6", "", { "dependencies": { "mdast-util-to-markdown": "~0.6.0" } }, "sha512-/d51FFIfPsSmCIRNp7E6pozM9z1GYPIkSy1urQ8s/o4TC22BZ7DqfHFWiqBD23bc7J3vV1Fc9O4QIHBlfuit8A=="], + + "mdast-util-to-markdown": ["mdast-util-to-markdown@0.6.5", "", { "dependencies": { "@types/unist": "^2.0.0", "longest-streak": "^2.0.0", "mdast-util-to-string": "^2.0.0", "parse-entities": "^2.0.0", "repeat-string": "^1.0.0", "zwitch": "^1.0.0" } }, "sha512-XeV9sDE7ZlOQvs45C9UKMtfTcctcaj/pGwH8YLbMHoMOXNNCn2LsqVQOqrF1+/NU8lKDAqozme9SCXWyo9oAcQ=="], + + "mdast-util-to-string": ["mdast-util-to-string@2.0.0", "", {}, "sha512-AW4DRS3QbBayY/jJmD8437V1Gombjf8RSOUCMFBuo5iHi58AGEgVCKQ+ezHkZZDpAQS75hcBMpLqjpJTjtUL7w=="], + + "merge-stream": ["merge-stream@2.0.0", "", {}, "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w=="], + + "micromark": ["micromark@2.11.4", "", { "dependencies": { "debug": "^4.0.0", "parse-entities": "^2.0.0" } }, "sha512-+WoovN/ppKolQOFIAajxi7Lu9kInbPxFuTBVEavFcL8eAfVstoc5MocPmqBeAdBOJV00uaVjegzH4+MA0DN/uA=="], + + "micromark-extension-footnote": ["micromark-extension-footnote@0.3.2", "", { "dependencies": { "micromark": "~2.11.0" } }, "sha512-gr/BeIxbIWQoUm02cIfK7mdMZ/fbroRpLsck4kvFtjbzP4yi+OPVbnukTc/zy0i7spC2xYE/dbX1Sur8BEDJsQ=="], + + "micromark-extension-frontmatter": ["micromark-extension-frontmatter@0.2.2", "", { "dependencies": { "fault": "^1.0.0" } }, "sha512-q6nPLFCMTLtfsctAuS0Xh4vaolxSFUWUWR6PZSrXXiRy+SANGllpcqdXFv2z07l0Xz/6Hl40hK0ffNCJPH2n1A=="], + + "micromark-extension-gfm": ["micromark-extension-gfm@0.3.3", "", { "dependencies": { "micromark": "~2.11.0", "micromark-extension-gfm-autolink-literal": "~0.5.0", "micromark-extension-gfm-strikethrough": "~0.6.5", "micromark-extension-gfm-table": "~0.4.0", "micromark-extension-gfm-tagfilter": "~0.3.0", "micromark-extension-gfm-task-list-item": "~0.3.0" } }, "sha512-oVN4zv5/tAIA+l3GbMi7lWeYpJ14oQyJ3uEim20ktYFAcfX1x3LNlFGGlmrZHt7u9YlKExmyJdDGaTt6cMSR/A=="], + + "micromark-extension-gfm-autolink-literal": ["micromark-extension-gfm-autolink-literal@0.5.7", "", { "dependencies": { "micromark": "~2.11.3" } }, "sha512-ePiDGH0/lhcngCe8FtH4ARFoxKTUelMp4L7Gg2pujYD5CSMb9PbblnyL+AAMud/SNMyusbS2XDSiPIRcQoNFAw=="], + + "micromark-extension-gfm-strikethrough": ["micromark-extension-gfm-strikethrough@0.6.5", "", { "dependencies": { "micromark": "~2.11.0" } }, "sha512-PpOKlgokpQRwUesRwWEp+fHjGGkZEejj83k9gU5iXCbDG+XBA92BqnRKYJdfqfkrRcZRgGuPuXb7DaK/DmxOhw=="], + + "micromark-extension-gfm-table": ["micromark-extension-gfm-table@0.4.3", "", { "dependencies": { "micromark": "~2.11.0" } }, "sha512-hVGvESPq0fk6ALWtomcwmgLvH8ZSVpcPjzi0AjPclB9FsVRgMtGZkUcpE0zgjOCFAznKepF4z3hX8z6e3HODdA=="], + + "micromark-extension-gfm-tagfilter": ["micromark-extension-gfm-tagfilter@0.3.0", "", {}, "sha512-9GU0xBatryXifL//FJH+tAZ6i240xQuFrSL7mYi8f4oZSbc+NvXjkrHemeYP0+L4ZUT+Ptz3b95zhUZnMtoi/Q=="], + + "micromark-extension-gfm-task-list-item": ["micromark-extension-gfm-task-list-item@0.3.3", "", { "dependencies": { "micromark": "~2.11.0" } }, "sha512-0zvM5iSLKrc/NQl84pZSjGo66aTGd57C1idmlWmE87lkMcXrTxg1uXa/nXomxJytoje9trP0NDLvw4bZ/Z/XCQ=="], + + "mime-db": ["mime-db@1.54.0", "", {}, "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ=="], + + "mime-types": ["mime-types@3.0.1", "", { "dependencies": { "mime-db": "^1.54.0" } }, "sha512-xRc4oEhT6eaBpU1XF7AjpOFD+xQmXNB5OVKwp4tqCuBpHLS/ZbBDrc07mYTDqVMg6PfxUjjNp85O6Cd2Z/5HWA=="], + + "mimic-fn": ["mimic-fn@4.0.0", "", {}, "sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw=="], + + "mimic-function": ["mimic-function@5.0.1", "", {}, "sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA=="], + + "mimic-response": ["mimic-response@3.1.0", "", {}, "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ=="], + + "minimatch": ["minimatch@3.1.2", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw=="], + + "minimist": ["minimist@1.2.8", "", {}, "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA=="], + + "minipass": ["minipass@7.1.2", "", {}, "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw=="], + + "mkdirp-classic": ["mkdirp-classic@0.5.3", "", {}, "sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A=="], + + "mock-property": ["mock-property@1.1.0", "", { "dependencies": { "define-data-property": "^1.1.4", "functions-have-names": "^1.2.3", "gopd": "^1.0.1", "has-property-descriptors": "^1.0.2", "hasown": "^2.0.2", "isarray": "^2.0.5", "object-inspect": "^1.13.2" } }, "sha512-1/JjbLoGwv87xVsutkX0XJc0M0W4kb40cZl/K41xtTViBOD9JuFPKfyMNTrLJ/ivYAd0aPqu/vduamXO0emTFQ=="], + + "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="], + + "mute-stream": ["mute-stream@2.0.0", "", {}, "sha512-WWdIxpyjEn+FhQJQQv9aQAYlHoNVdzIzUySNV1gHUPDSdZJ3yZn7pAAbQcV7B56Mvu881q9FZV+0Vx2xC44VWA=="], + + "nanoid": ["nanoid@3.3.11", "", { "bin": "bin/nanoid.cjs" }, "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w=="], + + "napi-build-utils": ["napi-build-utils@2.0.0", "", {}, "sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA=="], + + "natural-compare": ["natural-compare@1.4.0", "", {}, "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw=="], + + "netmask": ["netmask@2.0.2", "", {}, "sha512-dBpDMdxv9Irdq66304OLfEmQ9tbNRFnFTuZiLo+bD+r332bBmMJ8GBLXklIXXgxd3+v9+KUnZaUR5PJMa75Gsg=="], + + "new-github-release-url": ["new-github-release-url@2.0.0", "", { "dependencies": { "type-fest": "^2.5.1" } }, "sha512-NHDDGYudnvRutt/VhKFlX26IotXe1w0cmkDm6JGquh5bz/bDTw0LufSmH/GxTjEdpHEO+bVKFTwdrcGa/9XlKQ=="], + + "node-abi": ["node-abi@3.87.0", "", { "dependencies": { "semver": "^7.3.5" } }, "sha512-+CGM1L1CgmtheLcBuleyYOn7NWPVu0s0EJH2C4puxgEZb9h8QpR9G2dBfZJOAUhi7VQxuBPMd0hiISWcTyiYyQ=="], + + "node-fetch-native": ["node-fetch-native@1.6.7", "", {}, "sha512-g9yhqoedzIUm0nTnTqAQvueMPVOuIY16bqgAJJC8XOOubYFNwz6IER9qs0Gq2Xd0+CecCKFjtdDTMA4u4xG06Q=="], + + "npm-run-path": ["npm-run-path@5.3.0", "", { "dependencies": { "path-key": "^4.0.0" } }, "sha512-ppwTtiJZq0O/ai0z7yfudtBpWIoxM8yE6nHi1X47eFR2EWORqfbu6CnPlNsjeN683eT0qG6H/Pyf9fCcvjnnnQ=="], + + "nth-check": ["nth-check@2.1.1", "", { "dependencies": { "boolbase": "^1.0.0" } }, "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w=="], + + "nypm": ["nypm@0.6.2", "", { "dependencies": { "citty": "^0.1.6", "consola": "^3.4.2", "pathe": "^2.0.3", "pkg-types": "^2.3.0", "tinyexec": "^1.0.1" }, "bin": "dist/cli.mjs" }, "sha512-7eM+hpOtrKrBDCh7Ypu2lJ9Z7PNZBdi/8AT3AX8xoCj43BBVHD0hPSTEvMtkMpfs8FCqBGhxB+uToIQimA111g=="], + + "object-inspect": ["object-inspect@1.13.4", "", {}, "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew=="], + + "object-is": ["object-is@1.1.6", "", { "dependencies": { "call-bind": "^1.0.7", "define-properties": "^1.2.1" } }, "sha512-F8cZ+KfGlSGi09lJT7/Nd6KJZ9ygtvYC0/UYYLI9nmQKLMnydpB9yvbv9K1uSkEu7FU9vYPmVwLg328tX+ot3Q=="], + + "object-keys": ["object-keys@1.1.1", "", {}, "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA=="], + + "object.assign": ["object.assign@4.1.7", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.3", "define-properties": "^1.2.1", "es-object-atoms": "^1.0.0", "has-symbols": "^1.1.0", "object-keys": "^1.1.1" } }, "sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw=="], + + "ohash": ["ohash@2.0.11", "", {}, "sha512-RdR9FQrFwNBNXAr4GixM8YaRZRJ5PUWbKYbE5eOsrwAjJW0q2REGcf79oYPsLyskQCZG1PLN+S/K1V00joZAoQ=="], + + "once": ["once@1.4.0", "", { "dependencies": { "wrappy": "1" } }, "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w=="], + + "onetime": ["onetime@7.0.0", "", { "dependencies": { "mimic-function": "^5.0.0" } }, "sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ=="], + + "open": ["open@10.2.0", "", { "dependencies": { "default-browser": "^5.2.1", "define-lazy-prop": "^3.0.0", "is-inside-container": "^1.0.0", "wsl-utils": "^0.1.0" } }, "sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA=="], + + "optionator": ["optionator@0.9.4", "", { "dependencies": { "deep-is": "^0.1.3", "fast-levenshtein": "^2.0.6", "levn": "^0.4.1", "prelude-ls": "^1.2.1", "type-check": "^0.4.0", "word-wrap": "^1.2.5" } }, "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g=="], + + "ora": ["ora@9.0.0", "", { "dependencies": { "chalk": "^5.6.2", "cli-cursor": "^5.0.0", "cli-spinners": "^3.2.0", "is-interactive": "^2.0.0", "is-unicode-supported": "^2.1.0", "log-symbols": "^7.0.1", "stdin-discarder": "^0.2.2", "string-width": "^8.1.0", "strip-ansi": "^7.1.2" } }, "sha512-m0pg2zscbYgWbqRR6ABga5c3sZdEon7bSgjnlXC64kxtxLOyjRcbbUkLj7HFyy/FTD+P2xdBWu8snGhYI0jc4A=="], + + "os-name": ["os-name@6.1.0", "", { "dependencies": { "macos-release": "^3.3.0", "windows-release": "^6.1.0" } }, "sha512-zBd1G8HkewNd2A8oQ8c6BN/f/c9EId7rSUueOLGu28govmUctXmM+3765GwsByv9nYUdrLqHphXlYIc86saYsg=="], + + "own-keys": ["own-keys@1.0.1", "", { "dependencies": { "get-intrinsic": "^1.2.6", "object-keys": "^1.1.1", "safe-push-apply": "^1.0.0" } }, "sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg=="], + + "p-limit": ["p-limit@3.1.0", "", { "dependencies": { "yocto-queue": "^0.1.0" } }, "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ=="], + + "p-locate": ["p-locate@5.0.0", "", { "dependencies": { "p-limit": "^3.0.2" } }, "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw=="], + + "pac-proxy-agent": ["pac-proxy-agent@7.2.0", "", { "dependencies": { "@tootallnate/quickjs-emscripten": "^0.23.0", "agent-base": "^7.1.2", "debug": "^4.3.4", "get-uri": "^6.0.1", "http-proxy-agent": "^7.0.0", "https-proxy-agent": "^7.0.6", "pac-resolver": "^7.0.1", "socks-proxy-agent": "^8.0.5" } }, "sha512-TEB8ESquiLMc0lV8vcd5Ql/JAKAoyzHFXaStwjkzpOpC5Yv+pIzLfHvjTSdf3vpa2bMiUQrg9i6276yn8666aA=="], + + "pac-resolver": ["pac-resolver@7.0.1", "", { "dependencies": { "degenerator": "^5.0.0", "netmask": "^2.0.2" } }, "sha512-5NPgf87AT2STgwa2ntRMr45jTKrYBGkVU36yT0ig/n/GMAa3oPqhZfIQ2kMEimReg0+t9kZViDVZ83qfVUlckg=="], + + "package-json-from-dist": ["package-json-from-dist@1.0.1", "", {}, "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw=="], + + "parent-module": ["parent-module@1.0.1", "", { "dependencies": { "callsites": "^3.0.0" } }, "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g=="], + + "parse-entities": ["parse-entities@2.0.0", "", { "dependencies": { "character-entities": "^1.0.0", "character-entities-legacy": "^1.0.0", "character-reference-invalid": "^1.0.0", "is-alphanumerical": "^1.0.0", "is-decimal": "^1.0.0", "is-hexadecimal": "^1.0.0" } }, "sha512-kkywGpCcRYhqQIchaWqZ875wzpS/bMKhz5HnN3p7wveJTkTtyAB/AlnS0f8DFSqYW1T82t6yEAkEcB+A1I3MbQ=="], + + "parse-path": ["parse-path@7.1.0", "", { "dependencies": { "protocols": "^2.0.0" } }, "sha512-EuCycjZtfPcjWk7KTksnJ5xPMvWGA/6i4zrLYhRG0hGvC3GPU/jGUj3Cy+ZR0v30duV3e23R95T1lE2+lsndSw=="], + + "parse-url": ["parse-url@9.2.0", "", { "dependencies": { "@types/parse-path": "^7.0.0", "parse-path": "^7.0.0" } }, "sha512-bCgsFI+GeGWPAvAiUv63ZorMeif3/U0zaXABGJbOWt5OH2KCaPHF6S+0ok4aqM9RuIPGyZdx9tR9l13PsW4AYQ=="], + + "parse5": ["parse5@7.3.0", "", { "dependencies": { "entities": "^6.0.0" } }, "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw=="], + + "parse5-htmlparser2-tree-adapter": ["parse5-htmlparser2-tree-adapter@7.1.0", "", { "dependencies": { "domhandler": "^5.0.3", "parse5": "^7.0.0" } }, "sha512-ruw5xyKs6lrpo9x9rCZqZZnIUntICjQAd0Wsmp396Ul9lN/h+ifgVV1x1gZHi8euej6wTfpqX8j+BFQxF0NS/g=="], + + "parse5-parser-stream": ["parse5-parser-stream@7.1.2", "", { "dependencies": { "parse5": "^7.0.0" } }, "sha512-JyeQc9iwFLn5TbvvqACIF/VXG6abODeB3Fwmv/TGdLk2LfbWkaySGY72at4+Ty7EkPZj854u4CrICqNk2qIbow=="], + + "path-exists": ["path-exists@4.0.0", "", {}, "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w=="], + + "path-is-absolute": ["path-is-absolute@1.0.1", "", {}, "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg=="], + + "path-key": ["path-key@3.1.1", "", {}, "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="], + + "path-parse": ["path-parse@1.0.7", "", {}, "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw=="], + + "path-scurry": ["path-scurry@1.11.1", "", { "dependencies": { "lru-cache": "^10.2.0", "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" } }, "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA=="], + + "pathe": ["pathe@2.0.3", "", {}, "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w=="], + + "pathval": ["pathval@2.0.1", "", {}, "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ=="], + + "perfect-debounce": ["perfect-debounce@2.0.0", "", {}, "sha512-fkEH/OBiKrqqI/yIgjR92lMfs2K8105zt/VT6+7eTjNwisrsh47CeIED9z58zI7DfKdH3uHAn25ziRZn3kgAow=="], + + "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="], + + "picomatch": ["picomatch@4.0.3", "", {}, "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q=="], + + "pkg-types": ["pkg-types@2.3.0", "", { "dependencies": { "confbox": "^0.2.2", "exsolve": "^1.0.7", "pathe": "^2.0.3" } }, "sha512-SIqCzDRg0s9npO5XQ3tNZioRY1uK06lA41ynBC1YmFTmnY6FjUjVt6s4LoADmwoig1qqD0oK8h1p/8mlMx8Oig=="], + + "possible-typed-array-names": ["possible-typed-array-names@1.1.0", "", {}, "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg=="], + + "postcss": ["postcss@8.5.6", "", { "dependencies": { "nanoid": "^3.3.11", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg=="], + + "prebuild-install": ["prebuild-install@7.1.3", "", { "dependencies": { "detect-libc": "^2.0.0", "expand-template": "^2.0.3", "github-from-package": "0.0.0", "minimist": "^1.2.3", "mkdirp-classic": "^0.5.3", "napi-build-utils": "^2.0.0", "node-abi": "^3.3.0", "pump": "^3.0.0", "rc": "^1.2.7", "simple-get": "^4.0.0", "tar-fs": "^2.0.0", "tunnel-agent": "^0.6.0" }, "bin": { "prebuild-install": "bin.js" } }, "sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug=="], + + "prelude-ls": ["prelude-ls@1.2.1", "", {}, "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g=="], + + "prettier": ["prettier@3.6.2", "", { "bin": "bin/prettier.cjs" }, "sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ=="], + + "prettier-linter-helpers": ["prettier-linter-helpers@1.0.0", "", { "dependencies": { "fast-diff": "^1.1.2" } }, "sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w=="], + + "protocols": ["protocols@2.0.2", "", {}, "sha512-hHVTzba3wboROl0/aWRRG9dMytgH6ow//STBZh43l/wQgmMhYhOFi0EHWAPtoCz9IAUymsyP0TSBHkhgMEGNnQ=="], + + "proxy-agent": ["proxy-agent@6.5.0", "", { "dependencies": { "agent-base": "^7.1.2", "debug": "^4.3.4", "http-proxy-agent": "^7.0.1", "https-proxy-agent": "^7.0.6", "lru-cache": "^7.14.1", "pac-proxy-agent": "^7.1.0", "proxy-from-env": "^1.1.0", "socks-proxy-agent": "^8.0.5" } }, "sha512-TmatMXdr2KlRiA2CyDu8GqR8EjahTG3aY3nXjdzFyoZbmB8hrBsTyMezhULIXKnC0jpfjlmiZ3+EaCzoInSu/A=="], + + "proxy-from-env": ["proxy-from-env@1.1.0", "", {}, "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg=="], + + "pump": ["pump@3.0.3", "", { "dependencies": { "end-of-stream": "^1.1.0", "once": "^1.3.1" } }, "sha512-todwxLMY7/heScKmntwQG8CXVkWUOdYxIvY2s0VWAAMh/nd8SoYiRaKjlr7+iCs984f2P8zvrfWcDDYVb73NfA=="], + + "punycode": ["punycode@2.3.1", "", {}, "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg=="], + + "rc": ["rc@1.2.8", "", { "dependencies": { "deep-extend": "^0.6.0", "ini": "~1.3.0", "minimist": "^1.2.0", "strip-json-comments": "~2.0.1" }, "bin": { "rc": "./cli.js" } }, "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw=="], + + "rc9": ["rc9@2.1.2", "", { "dependencies": { "defu": "^6.1.4", "destr": "^2.0.3" } }, "sha512-btXCnMmRIBINM2LDZoEmOogIZU7Qe7zn4BpomSKZ/ykbLObuBdvG+mFq11DL6fjH1DRwHhrlgtYWG96bJiC7Cg=="], + + "react": ["react@19.1.1", "", {}, "sha512-w8nqGImo45dmMIfljjMwOGtbmC/mk4CMYhWIicdSflH91J9TyCyczcPFXJzrZ/ZXcgGRFeP6BU0BEJTw6tZdfQ=="], + + "react-dom": ["react-dom@19.1.1", "", { "dependencies": { "scheduler": "^0.26.0" }, "peerDependencies": { "react": "^19.1.1" } }, "sha512-Dlq/5LAZgF0Gaz6yiqZCf6VCcZs1ghAJyrsu84Q/GT0gV+mCxbfmKNoGRKBYMJ8IEdGPqu49YWXD02GCknEDkw=="], + + "readable-stream": ["readable-stream@3.6.2", "", { "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" } }, "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA=="], + + "readdirp": ["readdirp@4.1.2", "", {}, "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg=="], + + "reflect.getprototypeof": ["reflect.getprototypeof@1.0.10", "", { "dependencies": { "call-bind": "^1.0.8", "define-properties": "^1.2.1", "es-abstract": "^1.23.9", "es-errors": "^1.3.0", "es-object-atoms": "^1.0.0", "get-intrinsic": "^1.2.7", "get-proto": "^1.0.1", "which-builtin-type": "^1.2.1" } }, "sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw=="], + + "regexp.prototype.flags": ["regexp.prototype.flags@1.5.4", "", { "dependencies": { "call-bind": "^1.0.8", "define-properties": "^1.2.1", "es-errors": "^1.3.0", "get-proto": "^1.0.1", "gopd": "^1.2.0", "set-function-name": "^2.0.2" } }, "sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA=="], + + "release-it": ["release-it@19.0.5", "", { "dependencies": { "@nodeutils/defaults-deep": "1.1.0", "@octokit/rest": "22.0.0", "@phun-ky/typeof": "2.0.3", "async-retry": "1.3.3", "c12": "3.3.0", "ci-info": "^4.3.0", "eta": "4.0.1", "git-url-parse": "16.1.0", "inquirer": "12.9.6", "issue-parser": "7.0.1", "lodash.merge": "4.6.2", "mime-types": "3.0.1", "new-github-release-url": "2.0.0", "open": "10.2.0", "ora": "9.0.0", "os-name": "6.1.0", "proxy-agent": "6.5.0", "semver": "7.7.2", "tinyglobby": "0.2.15", "undici": "6.21.3", "url-join": "5.0.0", "wildcard-match": "5.1.4", "yargs-parser": "21.1.1" }, "bin": "bin/release-it.js" }, "sha512-bYlUKC0TQroBKi8jQUeoxLHql4d9Fx/2EQLHPKUobXTNSiTS2WY8vlgdHZRhRjVEMyAWwyadJVKfFZnRJuRn4Q=="], + + "remark-footnotes": ["remark-footnotes@3.0.0", "", { "dependencies": { "mdast-util-footnote": "^0.1.0", "micromark-extension-footnote": "^0.3.0" } }, "sha512-ZssAvH9FjGYlJ/PBVKdSmfyPc3Cz4rTWgZLI4iE/SX8Nt5l3o3oEjv3wwG5VD7xOjktzdwp5coac+kJV9l4jgg=="], + + "remark-frontmatter": ["remark-frontmatter@3.0.0", "", { "dependencies": { "mdast-util-frontmatter": "^0.2.0", "micromark-extension-frontmatter": "^0.2.0" } }, "sha512-mSuDd3svCHs+2PyO29h7iijIZx4plX0fheacJcAoYAASfgzgVIcXGYSq9GFyYocFLftQs8IOmmkgtOovs6d4oA=="], + + "remark-gfm": ["remark-gfm@1.0.0", "", { "dependencies": { "mdast-util-gfm": "^0.1.0", "micromark-extension-gfm": "^0.3.0" } }, "sha512-KfexHJCiqvrdBZVbQ6RopMZGwaXz6wFJEfByIuEwGf0arvITHjiKKZ1dpXujjH9KZdm1//XJQwgfnJ3lmXaDPA=="], + + "remark-parse": ["remark-parse@9.0.0", "", { "dependencies": { "mdast-util-from-markdown": "^0.8.0" } }, "sha512-geKatMwSzEXKHuzBNU1z676sGcDcFoChMK38TgdHJNAYfFtsfHDQG7MoJAjs6sgYMqyLduCYWDIWZIxiPeafEw=="], + + "repeat-string": ["repeat-string@1.6.1", "", {}, "sha512-PV0dzCYDNfRi1jCDbJzpW7jNNDRuCOG/jI5ctQcGKt/clZD+YcPS3yIlWuTJMmESC8aevCFmWJy5wjAFgNqN6w=="], + + "resolve": ["resolve@2.0.0-next.5", "", { "dependencies": { "is-core-module": "^2.13.0", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, "bin": "bin/resolve" }, "sha512-U7WjGVG9sH8tvjW5SmGbQuui75FiyjAX72HX15DwBBwF9dNiQZRQAg9nnPhYy+TUnE0+VcrttuvNI8oSxZcocA=="], + + "resolve-from": ["resolve-from@4.0.0", "", {}, "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g=="], + + "restore-cursor": ["restore-cursor@5.1.0", "", { "dependencies": { "onetime": "^7.0.0", "signal-exit": "^4.1.0" } }, "sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA=="], + + "retry": ["retry@0.13.1", "", {}, "sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg=="], + + "riteway": ["riteway@9.0.0-rc.1", "", { "dependencies": { "cheerio": "1.1.2", "esm": "3.2.25", "react-dom": "19.1.1", "tape": "^5.9.0", "vitest": "^3.2.4" }, "bin": "bin/riteway" }, "sha512-r6XrvFX9FSce/yG/HOsNtDqyh4E25k55PXLvGn4d2bR5dQqzB5jhpfSgzsdCtHE6kWNZrIaMJZ9aoB0wn63W9A=="], + + "rollup": ["rollup@4.52.2", "", { "dependencies": { "@types/estree": "1.0.8" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.52.2", "@rollup/rollup-android-arm64": "4.52.2", "@rollup/rollup-darwin-arm64": "4.52.2", "@rollup/rollup-darwin-x64": "4.52.2", "@rollup/rollup-freebsd-arm64": "4.52.2", "@rollup/rollup-freebsd-x64": "4.52.2", "@rollup/rollup-linux-arm-gnueabihf": "4.52.2", "@rollup/rollup-linux-arm-musleabihf": "4.52.2", "@rollup/rollup-linux-arm64-gnu": "4.52.2", "@rollup/rollup-linux-arm64-musl": "4.52.2", "@rollup/rollup-linux-loong64-gnu": "4.52.2", "@rollup/rollup-linux-ppc64-gnu": "4.52.2", "@rollup/rollup-linux-riscv64-gnu": "4.52.2", "@rollup/rollup-linux-riscv64-musl": "4.52.2", "@rollup/rollup-linux-s390x-gnu": "4.52.2", "@rollup/rollup-linux-x64-gnu": "4.52.2", "@rollup/rollup-linux-x64-musl": "4.52.2", "@rollup/rollup-openharmony-arm64": "4.52.2", "@rollup/rollup-win32-arm64-msvc": "4.52.2", "@rollup/rollup-win32-ia32-msvc": "4.52.2", "@rollup/rollup-win32-x64-gnu": "4.52.2", "@rollup/rollup-win32-x64-msvc": "4.52.2", "fsevents": "~2.3.2" }, "bin": "dist/bin/rollup" }, "sha512-I25/2QgoROE1vYV+NQ1En9T9UFB9Cmfm2CJ83zZOlaDpvz29wGQSZXWKw7MiNXau7wYgB/T9fVIdIuEQ+KbiiA=="], + + "run-applescript": ["run-applescript@7.1.0", "", {}, "sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q=="], + + "run-async": ["run-async@4.0.6", "", {}, "sha512-IoDlSLTs3Yq593mb3ZoKWKXMNu3UpObxhgA/Xuid5p4bbfi2jdY1Hj0m1K+0/tEuQTxIGMhQDqGjKb7RuxGpAQ=="], + + "rxjs": ["rxjs@7.8.2", "", { "dependencies": { "tslib": "^2.1.0" } }, "sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA=="], + + "safe-array-concat": ["safe-array-concat@1.1.3", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.2", "get-intrinsic": "^1.2.6", "has-symbols": "^1.1.0", "isarray": "^2.0.5" } }, "sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q=="], + + "safe-buffer": ["safe-buffer@5.2.1", "", {}, "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="], + + "safe-push-apply": ["safe-push-apply@1.0.0", "", { "dependencies": { "es-errors": "^1.3.0", "isarray": "^2.0.5" } }, "sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA=="], + + "safe-regex-test": ["safe-regex-test@1.1.0", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "is-regex": "^1.2.1" } }, "sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw=="], + + "safer-buffer": ["safer-buffer@2.1.2", "", {}, "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="], + + "scheduler": ["scheduler@0.26.0", "", {}, "sha512-NlHwttCI/l5gCPR3D1nNXtWABUmBwvZpEQiD4IXSbIDq8BzLIK/7Ir5gTFSGZDUu37K5cMNp0hFtzO38sC7gWA=="], + + "section-matter": ["section-matter@1.0.0", "", { "dependencies": { "extend-shallow": "^2.0.1", "kind-of": "^6.0.0" } }, "sha512-vfD3pmTzGpufjScBh50YHKzEu2lxBWhVEHsNGoEXmCmn2hKGfeNLYMzCJpe8cD7gqX7TJluOVpBkAequ6dgMmA=="], + + "semver": ["semver@7.7.2", "", { "bin": "bin/semver.js" }, "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA=="], + + "set-function-length": ["set-function-length@1.2.2", "", { "dependencies": { "define-data-property": "^1.1.4", "es-errors": "^1.3.0", "function-bind": "^1.1.2", "get-intrinsic": "^1.2.4", "gopd": "^1.0.1", "has-property-descriptors": "^1.0.2" } }, "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg=="], + + "set-function-name": ["set-function-name@2.0.2", "", { "dependencies": { "define-data-property": "^1.1.4", "es-errors": "^1.3.0", "functions-have-names": "^1.2.3", "has-property-descriptors": "^1.0.2" } }, "sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ=="], + + "set-proto": ["set-proto@1.0.0", "", { "dependencies": { "dunder-proto": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.0.0" } }, "sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw=="], + + "shebang-command": ["shebang-command@2.0.0", "", { "dependencies": { "shebang-regex": "^3.0.0" } }, "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA=="], + + "shebang-regex": ["shebang-regex@3.0.0", "", {}, "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="], + + "side-channel": ["side-channel@1.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.3", "side-channel-list": "^1.0.0", "side-channel-map": "^1.0.1", "side-channel-weakmap": "^1.0.2" } }, "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw=="], + + "side-channel-list": ["side-channel-list@1.0.0", "", { "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.3" } }, "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA=="], + + "side-channel-map": ["side-channel-map@1.0.1", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.5", "object-inspect": "^1.13.3" } }, "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA=="], + + "side-channel-weakmap": ["side-channel-weakmap@1.0.2", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.5", "object-inspect": "^1.13.3", "side-channel-map": "^1.0.1" } }, "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A=="], + + "siginfo": ["siginfo@2.0.0", "", {}, "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g=="], + + "signal-exit": ["signal-exit@4.1.0", "", {}, "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw=="], + + "simple-concat": ["simple-concat@1.0.1", "", {}, "sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q=="], + + "simple-get": ["simple-get@4.0.1", "", { "dependencies": { "decompress-response": "^6.0.0", "once": "^1.3.1", "simple-concat": "^1.0.0" } }, "sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA=="], + + "smart-buffer": ["smart-buffer@4.2.0", "", {}, "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg=="], + + "socks": ["socks@2.8.7", "", { "dependencies": { "ip-address": "^10.0.1", "smart-buffer": "^4.2.0" } }, "sha512-HLpt+uLy/pxB+bum/9DzAgiKS8CX1EvbWxI4zlmgGCExImLdiad2iCwXT5Z4c9c3Eq8rP2318mPW2c+QbtjK8A=="], + + "socks-proxy-agent": ["socks-proxy-agent@8.0.5", "", { "dependencies": { "agent-base": "^7.1.2", "debug": "^4.3.4", "socks": "^2.8.3" } }, "sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw=="], + + "source-map": ["source-map@0.6.1", "", {}, "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g=="], + + "source-map-js": ["source-map-js@1.2.1", "", {}, "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA=="], + + "sprintf-js": ["sprintf-js@1.0.3", "", {}, "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g=="], + + "stackback": ["stackback@0.0.2", "", {}, "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw=="], + + "std-env": ["std-env@3.9.0", "", {}, "sha512-UGvjygr6F6tpH7o2qyqR6QYpwraIjKSdtzyBdyytFOHmPZY917kwdwLG0RbOjWOnKmnm3PeHjaoLLMie7kPLQw=="], + + "stdin-discarder": ["stdin-discarder@0.2.2", "", {}, "sha512-UhDfHmA92YAlNnCfhmq0VeNL5bDbiZGg7sZ2IvPsXubGkiNa9EC+tUTsjBRsYUAz87btI6/1wf4XoVvQ3uRnmQ=="], + + "stop-iteration-iterator": ["stop-iteration-iterator@1.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "internal-slot": "^1.1.0" } }, "sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ=="], + + "string-width": ["string-width@8.1.0", "", { "dependencies": { "get-east-asian-width": "^1.3.0", "strip-ansi": "^7.1.0" } }, "sha512-Kxl3KJGb/gxkaUMOjRsQ8IrXiGW75O4E3RPjFIINOVH8AMl2SQ/yWdTzWwF3FevIX9LcMAjJW+GRwAlAbTSXdg=="], + + "string-width-cjs": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="], + + "string.prototype.trim": ["string.prototype.trim@1.2.10", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.2", "define-data-property": "^1.1.4", "define-properties": "^1.2.1", "es-abstract": "^1.23.5", "es-object-atoms": "^1.0.0", "has-property-descriptors": "^1.0.2" } }, "sha512-Rs66F0P/1kedk5lyYyH9uBzuiI/kNRmwJAR9quK6VOtIpZ2G+hMZd+HQbbv25MgCA6gEffoMZYxlTod4WcdrKA=="], + + "string.prototype.trimend": ["string.prototype.trimend@1.0.9", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.2", "define-properties": "^1.2.1", "es-object-atoms": "^1.0.0" } }, "sha512-G7Ok5C6E/j4SGfyLCloXTrngQIQU3PWtXGst3yM7Bea9FRURf1S42ZHlZZtsNque2FN2PoUhfZXYLNWwEr4dLQ=="], + + "string.prototype.trimstart": ["string.prototype.trimstart@1.0.8", "", { "dependencies": { "call-bind": "^1.0.7", "define-properties": "^1.2.1", "es-object-atoms": "^1.0.0" } }, "sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg=="], + + "string_decoder": ["string_decoder@1.3.0", "", { "dependencies": { "safe-buffer": "~5.2.0" } }, "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA=="], + + "strip-ansi": ["strip-ansi@7.1.2", "", { "dependencies": { "ansi-regex": "^6.0.1" } }, "sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA=="], + + "strip-ansi-cjs": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="], + + "strip-bom-string": ["strip-bom-string@1.0.0", "", {}, "sha512-uCC2VHvQRYu+lMh4My/sFNmF2klFymLX1wHJeXnbEJERpV/ZsVuonzerjfrGpIGF7LBVa1O7i9kjiWvJiFck8g=="], + + "strip-final-newline": ["strip-final-newline@3.0.0", "", {}, "sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw=="], + + "strip-json-comments": ["strip-json-comments@3.1.1", "", {}, "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig=="], + + "strip-literal": ["strip-literal@3.0.0", "", { "dependencies": { "js-tokens": "^9.0.1" } }, "sha512-TcccoMhJOM3OebGhSBEmp3UZ2SfDMZUEBdRA/9ynfLi8yYajyWX3JiXArcJt4Umh4vISpspkQIY8ZZoCqjbviA=="], + + "supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="], + + "supports-preserve-symlinks-flag": ["supports-preserve-symlinks-flag@1.0.0", "", {}, "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w=="], + + "synckit": ["synckit@0.11.11", "", { "dependencies": { "@pkgr/core": "^0.2.9" } }, "sha512-MeQTA1r0litLUf0Rp/iisCaL8761lKAZHaimlbGK4j0HysC4PLfqygQj9srcs0m2RdtDYnF8UuYyKpbjHYp7Jw=="], + + "tape": ["tape@5.9.0", "", { "dependencies": { "@ljharb/resumer": "^0.1.3", "@ljharb/through": "^2.3.13", "array.prototype.every": "^1.1.6", "call-bind": "^1.0.7", "deep-equal": "^2.2.3", "defined": "^1.0.1", "dotignore": "^0.1.2", "for-each": "^0.3.3", "get-package-type": "^0.1.0", "glob": "^7.2.3", "has-dynamic-import": "^2.1.0", "hasown": "^2.0.2", "inherits": "^2.0.4", "is-regex": "^1.1.4", "minimist": "^1.2.8", "mock-property": "^1.1.0", "object-inspect": "^1.13.2", "object-is": "^1.1.6", "object-keys": "^1.1.1", "object.assign": "^4.1.5", "resolve": "^2.0.0-next.5", "string.prototype.trim": "^1.2.9" }, "bin": "bin/tape" }, "sha512-czbGgxSVwRlbB3Ly/aqQrNwrDAzKHDW/kVXegp4hSFmR2c8qqm3hCgZbUy1+3QAQFGhPDG7J56UsV1uNilBFCA=="], + + "tar-fs": ["tar-fs@2.1.4", "", { "dependencies": { "chownr": "^1.1.1", "mkdirp-classic": "^0.5.2", "pump": "^3.0.0", "tar-stream": "^2.1.4" } }, "sha512-mDAjwmZdh7LTT6pNleZ05Yt65HC3E+NiQzl672vQG38jIrehtJk/J3mNwIg+vShQPcLF/LV7CMnDW6vjj6sfYQ=="], + + "tar-stream": ["tar-stream@2.2.0", "", { "dependencies": { "bl": "^4.0.3", "end-of-stream": "^1.4.1", "fs-constants": "^1.0.0", "inherits": "^2.0.3", "readable-stream": "^3.1.1" } }, "sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ=="], + + "test-exclude": ["test-exclude@7.0.1", "", { "dependencies": { "@istanbuljs/schema": "^0.1.2", "glob": "^10.4.1", "minimatch": "^9.0.4" } }, "sha512-pFYqmTw68LXVjeWJMST4+borgQP2AyMNbg1BpZh9LbyhUeNkeaPF9gzfPGUAnSMV3qPYdWUwDIjjCLiSDOl7vg=="], + + "tinybench": ["tinybench@2.9.0", "", {}, "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg=="], + + "tinyexec": ["tinyexec@0.3.2", "", {}, "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA=="], + + "tinyglobby": ["tinyglobby@0.2.15", "", { "dependencies": { "fdir": "^6.5.0", "picomatch": "^4.0.3" } }, "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ=="], + + "tinypool": ["tinypool@1.1.1", "", {}, "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg=="], + + "tinyrainbow": ["tinyrainbow@2.0.0", "", {}, "sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw=="], + + "tinyspy": ["tinyspy@4.0.4", "", {}, "sha512-azl+t0z7pw/z958Gy9svOTuzqIk6xq+NSheJzn5MMWtWTFywIacg2wUlzKFGtt3cthx0r2SxMK0yzJOR0IES7Q=="], + + "traverse": ["traverse@0.6.11", "", { "dependencies": { "gopd": "^1.2.0", "typedarray.prototype.slice": "^1.0.5", "which-typed-array": "^1.1.18" } }, "sha512-vxXDZg8/+p3gblxB6BhhG5yWVn1kGRlaL8O78UDXc3wRnPizB5g83dcvWV1jpDMIPnjZjOFuxlMmE82XJ4407w=="], + + "trough": ["trough@1.0.5", "", {}, "sha512-rvuRbTarPXmMb79SmzEp8aqXNKcK+y0XaB298IXueQ8I2PsrATcPBCSPyK/dDNa2iWOhKlfNnOjdAOTBU/nkFA=="], + + "tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="], + + "tunnel-agent": ["tunnel-agent@0.6.0", "", { "dependencies": { "safe-buffer": "^5.0.1" } }, "sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w=="], + + "type-check": ["type-check@0.4.0", "", { "dependencies": { "prelude-ls": "^1.2.1" } }, "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew=="], + + "type-fest": ["type-fest@2.19.0", "", {}, "sha512-RAH822pAdBgcNMAfWnCBU3CFZcfZ/i1eZjwFU/dsLKumyuuP3niueg2UAukXYF0E2AAoc82ZSSf9J0WQBinzHA=="], + + "typed-array-buffer": ["typed-array-buffer@1.0.3", "", { "dependencies": { "call-bound": "^1.0.3", "es-errors": "^1.3.0", "is-typed-array": "^1.1.14" } }, "sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw=="], + + "typed-array-byte-length": ["typed-array-byte-length@1.0.3", "", { "dependencies": { "call-bind": "^1.0.8", "for-each": "^0.3.3", "gopd": "^1.2.0", "has-proto": "^1.2.0", "is-typed-array": "^1.1.14" } }, "sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg=="], + + "typed-array-byte-offset": ["typed-array-byte-offset@1.0.4", "", { "dependencies": { "available-typed-arrays": "^1.0.7", "call-bind": "^1.0.8", "for-each": "^0.3.3", "gopd": "^1.2.0", "has-proto": "^1.2.0", "is-typed-array": "^1.1.15", "reflect.getprototypeof": "^1.0.9" } }, "sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ=="], + + "typed-array-length": ["typed-array-length@1.0.7", "", { "dependencies": { "call-bind": "^1.0.7", "for-each": "^0.3.3", "gopd": "^1.0.1", "is-typed-array": "^1.1.13", "possible-typed-array-names": "^1.0.0", "reflect.getprototypeof": "^1.0.6" } }, "sha512-3KS2b+kL7fsuk/eJZ7EQdnEmQoaho/r6KUef7hxvltNA5DR8NAUM+8wJMbJyZ4G9/7i3v5zPBIMN5aybAh2/Jg=="], + + "typedarray.prototype.slice": ["typedarray.prototype.slice@1.0.5", "", { "dependencies": { "call-bind": "^1.0.8", "define-properties": "^1.2.1", "es-abstract": "^1.23.9", "es-errors": "^1.3.0", "get-proto": "^1.0.1", "math-intrinsics": "^1.1.0", "typed-array-buffer": "^1.0.3", "typed-array-byte-offset": "^1.0.4" } }, "sha512-q7QNVDGTdl702bVFiI5eY4l/HkgCM6at9KhcFbgUAzezHFbOVy4+0O/lCjsABEQwbZPravVfBIiBVGo89yzHFg=="], + + "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="], + + "unbox-primitive": ["unbox-primitive@1.1.0", "", { "dependencies": { "call-bound": "^1.0.3", "has-bigints": "^1.0.2", "has-symbols": "^1.1.0", "which-boxed-primitive": "^1.1.1" } }, "sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw=="], + + "underscore": ["underscore@1.13.7", "", {}, "sha512-GMXzWtsc57XAtguZgaQViUOzs0KTkk8ojr3/xAxXLITqf/3EMwxC0inyETfDFjH/Krbhuep0HNbbjI9i/q3F3g=="], + + "undici": ["undici@6.21.3", "", {}, "sha512-gBLkYIlEnSp8pFbT64yFgGE6UIB9tAkhukC23PmMDCe5Nd+cRqKxSjw5y54MK2AZMgZfJWMaNE4nYUHgi1XEOw=="], + + "unified": ["unified@9.2.2", "", { "dependencies": { "bail": "^1.0.0", "extend": "^3.0.0", "is-buffer": "^2.0.0", "is-plain-obj": "^2.0.0", "trough": "^1.0.0", "vfile": "^4.0.0" } }, "sha512-Sg7j110mtefBD+qunSLO1lqOEKdrwBFBrR6Qd8f4uwkhWNlbkaqwHse6e7QvD3AP/MNoJdEDLaf8OxYyoWgorQ=="], + + "unist-util-is": ["unist-util-is@4.1.0", "", {}, "sha512-ZOQSsnce92GrxSqlnEEseX0gi7GH9zTJZ0p9dtu87WRb/37mMPO2Ilx1s/t9vBHrFhbgweUwb+t7cIn5dxPhZg=="], + + "unist-util-stringify-position": ["unist-util-stringify-position@2.0.3", "", { "dependencies": { "@types/unist": "^2.0.2" } }, "sha512-3faScn5I+hy9VleOq/qNbAd6pAx7iH5jYBMS9I1HgQVijz/4mv5Bvw5iw1sC/90CODiKo81G/ps8AJrISn687g=="], + + "unist-util-visit-parents": ["unist-util-visit-parents@3.1.1", "", { "dependencies": { "@types/unist": "^2.0.0", "unist-util-is": "^4.0.0" } }, "sha512-1KROIZWo6bcMrZEwiH2UrXDyalAa0uqzWCxCJj6lPOvTve2WkfgCytoDTPaMnodXh1WrXOq0haVYHj99ynJlsg=="], + + "universal-user-agent": ["universal-user-agent@7.0.3", "", {}, "sha512-TmnEAEAsBJVZM/AADELsK76llnwcf9vMKuPz8JflO1frO8Lchitr0fNaN9d+Ap0BjKtqWqd/J17qeDnXh8CL2A=="], + + "universalify": ["universalify@2.0.1", "", {}, "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw=="], + + "update-section": ["update-section@0.3.3", "", {}, "sha512-BpRZMZpgXLuTiKeiu7kK0nIPwGdyrqrs6EDSaXtjD/aQ2T+qVo9a5hRC3HN3iJjCMxNT/VxoLGQ7E/OzE5ucnw=="], + + "uri-js": ["uri-js@4.4.1", "", { "dependencies": { "punycode": "^2.1.0" } }, "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg=="], + + "url-join": ["url-join@5.0.0", "", {}, "sha512-n2huDr9h9yzd6exQVnH/jU5mr+Pfx08LRXXZhkLLetAMESRj+anQsTAh940iMrIetKAmry9coFuZQ2jY8/p3WA=="], + + "util-deprecate": ["util-deprecate@1.0.2", "", {}, "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="], + + "vfile": ["vfile@4.2.1", "", { "dependencies": { "@types/unist": "^2.0.0", "is-buffer": "^2.0.0", "unist-util-stringify-position": "^2.0.0", "vfile-message": "^2.0.0" } }, "sha512-O6AE4OskCG5S1emQ/4gl8zK586RqA3srz3nfK/Viy0UPToBc5Trp9BVFb1u0CjsKrAWwnpr4ifM/KBXPWwJbCA=="], + + "vfile-message": ["vfile-message@2.0.4", "", { "dependencies": { "@types/unist": "^2.0.0", "unist-util-stringify-position": "^2.0.0" } }, "sha512-DjssxRGkMvifUOJre00juHoP9DPWuzjxKuMDrhNbk2TdaYYBNMStsNhEOt3idrtI12VQYM/1+iM0KOzXi4pxwQ=="], + + "vite": ["vite@7.1.7", "", { "dependencies": { "esbuild": "^0.25.0", "fdir": "^6.5.0", "picomatch": "^4.0.3", "postcss": "^8.5.6", "rollup": "^4.43.0", "tinyglobby": "^0.2.15" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "jiti": ">=1.21.0", "less": "^4.0.0", "lightningcss": "^1.21.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "less", "lightningcss", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": "bin/vite.js" }, "sha512-VbA8ScMvAISJNJVbRDTJdCwqQoAareR/wutevKanhR2/1EkoXVZVkkORaYm/tNVCjP/UDTKtcw3bAkwOUdedmA=="], + + "vite-node": ["vite-node@3.2.4", "", { "dependencies": { "cac": "^6.7.14", "debug": "^4.4.1", "es-module-lexer": "^1.7.0", "pathe": "^2.0.3", "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0" }, "bin": "vite-node.mjs" }, "sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg=="], + + "vitest": ["vitest@3.2.4", "", { "dependencies": { "@types/chai": "^5.2.2", "@vitest/expect": "3.2.4", "@vitest/mocker": "3.2.4", "@vitest/pretty-format": "^3.2.4", "@vitest/runner": "3.2.4", "@vitest/snapshot": "3.2.4", "@vitest/spy": "3.2.4", "@vitest/utils": "3.2.4", "chai": "^5.2.0", "debug": "^4.4.1", "expect-type": "^1.2.1", "magic-string": "^0.30.17", "pathe": "^2.0.3", "picomatch": "^4.0.2", "std-env": "^3.9.0", "tinybench": "^2.9.0", "tinyexec": "^0.3.2", "tinyglobby": "^0.2.14", "tinypool": "^1.1.1", "tinyrainbow": "^2.0.0", "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0", "vite-node": "3.2.4", "why-is-node-running": "^2.3.0" }, "peerDependencies": { "@edge-runtime/vm": "*", "@types/debug": "^4.1.12", "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", "@vitest/browser": "3.2.4", "@vitest/ui": "3.2.4", "happy-dom": "*", "jsdom": "*" }, "optionalPeers": ["@edge-runtime/vm", "@types/debug", "@types/node", "@vitest/browser", "@vitest/ui", "happy-dom", "jsdom"], "bin": "vitest.mjs" }, "sha512-LUCP5ev3GURDysTWiP47wRRUpLKMOfPh+yKTx3kVIEiu5KOMeqzpnYNsKyOoVrULivR8tLcks4+lga33Whn90A=="], + + "whatwg-encoding": ["whatwg-encoding@3.1.1", "", { "dependencies": { "iconv-lite": "0.6.3" } }, "sha512-6qN4hJdMwfYBtE3YBTTHhoeuUrDBPZmbQaxWAqSALV/MeEnR5z1xd8UKud2RAkFoPkmB+hli1TZSnyi84xz1vQ=="], + + "whatwg-mimetype": ["whatwg-mimetype@4.0.0", "", {}, "sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg=="], + + "which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="], + + "which-boxed-primitive": ["which-boxed-primitive@1.1.1", "", { "dependencies": { "is-bigint": "^1.1.0", "is-boolean-object": "^1.2.1", "is-number-object": "^1.1.1", "is-string": "^1.1.1", "is-symbol": "^1.1.1" } }, "sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA=="], + + "which-builtin-type": ["which-builtin-type@1.2.1", "", { "dependencies": { "call-bound": "^1.0.2", "function.prototype.name": "^1.1.6", "has-tostringtag": "^1.0.2", "is-async-function": "^2.0.0", "is-date-object": "^1.1.0", "is-finalizationregistry": "^1.1.0", "is-generator-function": "^1.0.10", "is-regex": "^1.2.1", "is-weakref": "^1.0.2", "isarray": "^2.0.5", "which-boxed-primitive": "^1.1.0", "which-collection": "^1.0.2", "which-typed-array": "^1.1.16" } }, "sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q=="], + + "which-collection": ["which-collection@1.0.2", "", { "dependencies": { "is-map": "^2.0.3", "is-set": "^2.0.3", "is-weakmap": "^2.0.2", "is-weakset": "^2.0.3" } }, "sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw=="], + + "which-typed-array": ["which-typed-array@1.1.19", "", { "dependencies": { "available-typed-arrays": "^1.0.7", "call-bind": "^1.0.8", "call-bound": "^1.0.4", "for-each": "^0.3.5", "get-proto": "^1.0.1", "gopd": "^1.2.0", "has-tostringtag": "^1.0.2" } }, "sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw=="], + + "why-is-node-running": ["why-is-node-running@2.3.0", "", { "dependencies": { "siginfo": "^2.0.0", "stackback": "0.0.2" }, "bin": "cli.js" }, "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w=="], + + "wildcard-match": ["wildcard-match@5.1.4", "", {}, "sha512-wldeCaczs8XXq7hj+5d/F38JE2r7EXgb6WQDM84RVwxy81T/sxB5e9+uZLK9Q9oNz1mlvjut+QtvgaOQFPVq/g=="], + + "windows-release": ["windows-release@6.1.0", "", { "dependencies": { "execa": "^8.0.1" } }, "sha512-1lOb3qdzw6OFmOzoY0nauhLG72TpWtb5qgYPiSh/62rjc1XidBSDio2qw0pwHh17VINF217ebIkZJdFLZFn9SA=="], + + "word-wrap": ["word-wrap@1.2.5", "", {}, "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA=="], + + "wrap-ansi": ["wrap-ansi@6.2.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA=="], + + "wrap-ansi-cjs": ["wrap-ansi@7.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q=="], + + "wrappy": ["wrappy@1.0.2", "", {}, "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="], + + "wsl-utils": ["wsl-utils@0.1.0", "", { "dependencies": { "is-wsl": "^3.1.0" } }, "sha512-h3Fbisa2nKGPxCpm89Hk33lBLsnaGBvctQopaBSOW/uIs6FTe1ATyAnKFJrzVs9vpGdsTe73WF3V4lIsk4Gacw=="], + + "yargs-parser": ["yargs-parser@21.1.1", "", {}, "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw=="], + + "yocto-queue": ["yocto-queue@0.1.0", "", {}, "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q=="], + + "yoctocolors": ["yoctocolors@2.1.2", "", {}, "sha512-CzhO+pFNo8ajLM2d2IW/R93ipy99LWjtwblvC1RsoSUMZgyLbYFr221TnSNT7GjGdYui6P459mw9JH/g/zW2ug=="], + + "yoctocolors-cjs": ["yoctocolors-cjs@2.1.3", "", {}, "sha512-U/PBtDf35ff0D8X8D0jfdzHYEPFxAI7jJlxZXwCSez5M3190m+QobIfh+sWDWSHMCWWJN2AWamkegn6vr6YBTw=="], + + "zwitch": ["zwitch@1.0.5", "", {}, "sha512-V50KMwwzqJV0NpZIZFwfOD5/lyny3WlSzRiXgA0G7VUnRlqttta1L6UQIHzd6EuBY/cHGfwTIck7w1yH6Q5zUw=="], + + "@eslint-community/eslint-utils/eslint-visitor-keys": ["eslint-visitor-keys@3.4.3", "", {}, "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag=="], + + "@inquirer/external-editor/iconv-lite": ["iconv-lite@0.7.0", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-cf6L2Ds3h57VVmkZe+Pn+5APsT7FpqJtEhhieDCvrE2MK5Qk9MyffgQyuxQTm6BChfeZNtcOLHp9IcWRVcIcBQ=="], + + "@isaacs/cliui/string-width": ["string-width@5.1.2", "", { "dependencies": { "eastasianwidth": "^0.2.0", "emoji-regex": "^9.2.2", "strip-ansi": "^7.0.1" } }, "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA=="], + + "@isaacs/cliui/wrap-ansi": ["wrap-ansi@8.1.0", "", { "dependencies": { "ansi-styles": "^6.1.0", "string-width": "^5.0.1", "strip-ansi": "^7.0.1" } }, "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ=="], + + "@octokit/endpoint/@octokit/types": ["@octokit/types@14.1.0", "", { "dependencies": { "@octokit/openapi-types": "^25.1.0" } }, "sha512-1y6DgTy8Jomcpu33N+p5w58l6xyt55Ar2I91RPiIA0xCJBXyUAhXCcmZaDWSANiha7R9a6qJJ2CRomGPZ6f46g=="], + + "@octokit/graphql/@octokit/types": ["@octokit/types@14.1.0", "", { "dependencies": { "@octokit/openapi-types": "^25.1.0" } }, "sha512-1y6DgTy8Jomcpu33N+p5w58l6xyt55Ar2I91RPiIA0xCJBXyUAhXCcmZaDWSANiha7R9a6qJJ2CRomGPZ6f46g=="], + + "@octokit/plugin-paginate-rest/@octokit/types": ["@octokit/types@14.1.0", "", { "dependencies": { "@octokit/openapi-types": "^25.1.0" } }, "sha512-1y6DgTy8Jomcpu33N+p5w58l6xyt55Ar2I91RPiIA0xCJBXyUAhXCcmZaDWSANiha7R9a6qJJ2CRomGPZ6f46g=="], + + "@octokit/request/@octokit/types": ["@octokit/types@14.1.0", "", { "dependencies": { "@octokit/openapi-types": "^25.1.0" } }, "sha512-1y6DgTy8Jomcpu33N+p5w58l6xyt55Ar2I91RPiIA0xCJBXyUAhXCcmZaDWSANiha7R9a6qJJ2CRomGPZ6f46g=="], + + "@octokit/request-error/@octokit/types": ["@octokit/types@14.1.0", "", { "dependencies": { "@octokit/openapi-types": "^25.1.0" } }, "sha512-1y6DgTy8Jomcpu33N+p5w58l6xyt55Ar2I91RPiIA0xCJBXyUAhXCcmZaDWSANiha7R9a6qJJ2CRomGPZ6f46g=="], + + "cheerio/domhandler": ["domhandler@5.0.3", "", { "dependencies": { "domelementtype": "^2.3.0" } }, "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w=="], + + "cheerio/domutils": ["domutils@3.2.2", "", { "dependencies": { "dom-serializer": "^2.0.0", "domelementtype": "^2.3.0", "domhandler": "^5.0.3" } }, "sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw=="], + + "cheerio/htmlparser2": ["htmlparser2@10.0.0", "", { "dependencies": { "domelementtype": "^2.3.0", "domhandler": "^5.0.3", "domutils": "^3.2.1", "entities": "^6.0.0" } }, "sha512-TwAZM+zE5Tq3lrEHvOlvwgj1XLWQCtaaibSN11Q+gGBAS7Y1uZSWwXXRe4iF6OXnaq1riyQAPFOBtYc77Mxq0g=="], + + "cheerio/undici": ["undici@7.16.0", "", {}, "sha512-QEg3HPMll0o3t2ourKwOeUAZ159Kn9mx5pnzHRQO8+Wixmh88YdZRiIwat0iNzNNXn0yoEtXJqFpyW7eM8BV7g=="], + + "cheerio-select/domhandler": ["domhandler@5.0.3", "", { "dependencies": { "domelementtype": "^2.3.0" } }, "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w=="], + + "cheerio-select/domutils": ["domutils@3.2.2", "", { "dependencies": { "dom-serializer": "^2.0.0", "domelementtype": "^2.3.0", "domhandler": "^5.0.3" } }, "sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw=="], + + "css-select/domhandler": ["domhandler@5.0.3", "", { "dependencies": { "domelementtype": "^2.3.0" } }, "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w=="], + + "css-select/domutils": ["domutils@3.2.2", "", { "dependencies": { "dom-serializer": "^2.0.0", "domelementtype": "^2.3.0", "domhandler": "^5.0.3" } }, "sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw=="], + + "dom-serializer/domhandler": ["domhandler@5.0.3", "", { "dependencies": { "domelementtype": "^2.3.0" } }, "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w=="], + + "dom-serializer/entities": ["entities@4.5.0", "", {}, "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw=="], + + "domutils/dom-serializer": ["dom-serializer@1.4.1", "", { "dependencies": { "domelementtype": "^2.0.1", "domhandler": "^4.2.0", "entities": "^2.0.0" } }, "sha512-VHwB3KfrcOOkelEG2ZOfxqLZdfkil8PtJi4P8N2MMXucZq2yLp75ClViUlOVwyoHEDjYU433Aq+5zWP61+RGag=="], + + "eslint/ajv": ["ajv@6.12.6", "", { "dependencies": { "fast-deep-equal": "^3.1.1", "fast-json-stable-stringify": "^2.0.0", "json-schema-traverse": "^0.4.1", "uri-js": "^4.2.2" } }, "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g=="], + + "execa/onetime": ["onetime@6.0.0", "", { "dependencies": { "mimic-fn": "^4.0.0" } }, "sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ=="], + + "glob/minimatch": ["minimatch@9.0.5", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow=="], + + "gray-matter/js-yaml": ["js-yaml@3.14.2", "", { "dependencies": { "argparse": "^1.0.7", "esprima": "^4.0.0" }, "bin": "bin/js-yaml.js" }, "sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg=="], + + "npm-run-path/path-key": ["path-key@4.0.0", "", {}, "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ=="], + + "nypm/tinyexec": ["tinyexec@1.0.1", "", {}, "sha512-5uC6DDlmeqiOwCPmK9jMSdOuZTh8bU39Ys6yidB+UTt5hfZUPGAypSgFRiEp+jbi9qH40BLDvy85jIU88wKSqw=="], + + "ora/chalk": ["chalk@5.6.2", "", {}, "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA=="], + + "parse5/entities": ["entities@6.0.1", "", {}, "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g=="], + + "parse5-htmlparser2-tree-adapter/domhandler": ["domhandler@5.0.3", "", { "dependencies": { "domelementtype": "^2.3.0" } }, "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w=="], + + "path-scurry/lru-cache": ["lru-cache@10.4.3", "", {}, "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="], + + "rc/strip-json-comments": ["strip-json-comments@2.0.1", "", {}, "sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ=="], + + "string-width-cjs/emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="], + + "string-width-cjs/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="], + + "strip-ansi-cjs/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="], + + "tape/glob": ["glob@7.2.3", "", { "dependencies": { "fs.realpath": "^1.0.0", "inflight": "^1.0.4", "inherits": "2", "minimatch": "^3.1.1", "once": "^1.3.0", "path-is-absolute": "^1.0.0" } }, "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q=="], + + "test-exclude/minimatch": ["minimatch@9.0.5", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow=="], + + "wrap-ansi/string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="], + + "wrap-ansi/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="], + + "wrap-ansi-cjs/string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="], + + "wrap-ansi-cjs/strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="], + + "@isaacs/cliui/string-width/emoji-regex": ["emoji-regex@9.2.2", "", {}, "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg=="], + + "@isaacs/cliui/wrap-ansi/ansi-styles": ["ansi-styles@6.2.3", "", {}, "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg=="], + + "@octokit/endpoint/@octokit/types/@octokit/openapi-types": ["@octokit/openapi-types@25.1.0", "", {}, "sha512-idsIggNXUKkk0+BExUn1dQ92sfysJrje03Q0bv0e+KPLrvyqZF8MnBpFz8UNfYDwB3Ie7Z0TByjWfzxt7vseaA=="], + + "@octokit/graphql/@octokit/types/@octokit/openapi-types": ["@octokit/openapi-types@25.1.0", "", {}, "sha512-idsIggNXUKkk0+BExUn1dQ92sfysJrje03Q0bv0e+KPLrvyqZF8MnBpFz8UNfYDwB3Ie7Z0TByjWfzxt7vseaA=="], + + "@octokit/plugin-paginate-rest/@octokit/types/@octokit/openapi-types": ["@octokit/openapi-types@25.1.0", "", {}, "sha512-idsIggNXUKkk0+BExUn1dQ92sfysJrje03Q0bv0e+KPLrvyqZF8MnBpFz8UNfYDwB3Ie7Z0TByjWfzxt7vseaA=="], + + "@octokit/request-error/@octokit/types/@octokit/openapi-types": ["@octokit/openapi-types@25.1.0", "", {}, "sha512-idsIggNXUKkk0+BExUn1dQ92sfysJrje03Q0bv0e+KPLrvyqZF8MnBpFz8UNfYDwB3Ie7Z0TByjWfzxt7vseaA=="], + + "@octokit/request/@octokit/types/@octokit/openapi-types": ["@octokit/openapi-types@25.1.0", "", {}, "sha512-idsIggNXUKkk0+BExUn1dQ92sfysJrje03Q0bv0e+KPLrvyqZF8MnBpFz8UNfYDwB3Ie7Z0TByjWfzxt7vseaA=="], + + "cheerio/htmlparser2/entities": ["entities@6.0.1", "", {}, "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g=="], + + "domutils/dom-serializer/entities": ["entities@2.2.0", "", {}, "sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A=="], + + "eslint/ajv/json-schema-traverse": ["json-schema-traverse@0.4.1", "", {}, "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="], + + "glob/minimatch/brace-expansion": ["brace-expansion@2.0.2", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ=="], + + "gray-matter/js-yaml/argparse": ["argparse@1.0.10", "", { "dependencies": { "sprintf-js": "~1.0.2" } }, "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg=="], + + "string-width-cjs/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="], + + "test-exclude/minimatch/brace-expansion": ["brace-expansion@2.0.2", "", { "dependencies": { "balanced-match": "^1.0.0" } }, "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ=="], + + "wrap-ansi-cjs/string-width/emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="], + + "wrap-ansi-cjs/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="], + + "wrap-ansi/string-width/emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="], + + "wrap-ansi/strip-ansi/ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="], + } +} diff --git a/package.json b/package.json index 9c7447b..d2ce1a7 100644 --- a/package.json +++ b/package.json @@ -13,7 +13,8 @@ "format": "prettier --write . && echo 'Format complete.'", "format:check": "prettier --check . && echo 'Format check complete.'", "test": "vitest run && echo 'Test complete.' && npm run -s lint && npm run -s typecheck", - "test:unit": "vitest run --exclude '**/*-e2e.test.js' && echo 'Unit tests complete.' && npm run -s lint && npm run -s typecheck", + "test:unit": "vitest run --exclude '**/*-e2e.test.js' --exclude '**/create-schema.test.js' && echo 'Unit tests complete.' && npm run -s lint && npm run -s typecheck", + "test:bun": "bun test ai/tools/create-schema.test.js && echo 'Bun tests complete.'", "test:e2e": "vitest run **/*-e2e.test.js && echo 'E2E tests complete.'", "typecheck": "tsc --noEmit && echo 'Type check complete.'", "check-status": "[ -n \"$(git status --porcelain)\" ] && { echo '❌ Uncommitted changes'; exit 1; } || echo '✅ Git status is clean.'", @@ -67,6 +68,7 @@ "dependencies": { "@paralleldrive/cuid2": "^3.1.0", "@sinclair/typebox": "^0.34.41", + "better-sqlite3": "^12.6.2", "chalk": "^4.1.2", "commander": "^11.1.0", "error-causes": "^3.0.2", From 5bb833307264178bd4acbbe5df43795874eec333 Mon Sep 17 00:00:00 2001 From: Claude Date: Wed, 21 Jan 2026 00:10:04 +0000 Subject: [PATCH 7/7] Apply prettier formatting to schema files Auto-formatting from pre-commit hook. --- ai/index.md | 4 + ai/tools/create-schema.js | 22 ++- ai/tools/create-schema.test.js | 279 ++++++++++++++++++++------------- 3 files changed, 186 insertions(+), 119 deletions(-) diff --git a/ai/index.md b/ai/index.md index 0419529..12dc7e8 100644 --- a/ai/index.md +++ b/ai/index.md @@ -12,3 +12,7 @@ See [`commands/index.md`](./commands/index.md) for contents. See [`rules/index.md`](./rules/index.md) for contents. +### 📁 tools/ + +See [`tools/index.md`](./tools/index.md) for contents. + diff --git a/ai/tools/create-schema.js b/ai/tools/create-schema.js index e872a34..398ddca 100755 --- a/ai/tools/create-schema.js +++ b/ai/tools/create-schema.js @@ -4,7 +4,7 @@ * Creates the complete database schema for aidd indexing system */ -import { Database } from 'bun:sqlite'; +import { Database } from "bun:sqlite"; /** * Creates the complete database schema @@ -12,7 +12,7 @@ import { Database } from 'bun:sqlite'; */ export function createSchema(db) { // Enable foreign keys - db.exec('PRAGMA foreign_keys = ON'); + db.exec("PRAGMA foreign_keys = ON"); // Schema version tracking db.exec(` @@ -248,9 +248,13 @@ export function createSchema(db) { const version = 1; const now = Date.now(); - const existing = db.prepare('SELECT version FROM schema_version WHERE version = ?').get(version); + const existing = db + .prepare("SELECT version FROM schema_version WHERE version = ?") + .get(version); if (!existing) { - db.prepare('INSERT INTO schema_version (version, applied_at) VALUES (?, ?)').run(version, now); + db.prepare( + "INSERT INTO schema_version (version, applied_at) VALUES (?, ?)", + ).run(version, now); } return { version, tablesCreated: true }; @@ -260,7 +264,7 @@ export function createSchema(db) { * Main execution when run as script */ if (import.meta.main) { - const dbPath = process.argv[2] || '.aidd/index.db'; + const dbPath = process.argv[2] || ".aidd/index.db"; console.log(`Creating schema in ${dbPath}...`); @@ -270,11 +274,15 @@ if (import.meta.main) { console.log(`✓ Schema created successfully (version ${result.version})`); // Show table count - const tables = db.prepare(` + const tables = db + .prepare( + ` SELECT COUNT(*) as count FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' - `).get(); + `, + ) + .get(); console.log(`✓ Created ${tables.count} tables`); diff --git a/ai/tools/create-schema.test.js b/ai/tools/create-schema.test.js index e04c413..92b9795 100644 --- a/ai/tools/create-schema.test.js +++ b/ai/tools/create-schema.test.js @@ -1,305 +1,360 @@ -import { describe, test, beforeEach, afterEach } from 'vitest'; -import { assert } from 'riteway/vitest'; -import { Database } from 'bun:sqlite'; -import { createSchema } from './create-schema.js'; +import { describe, test, beforeEach, afterEach } from "vitest"; +import { assert } from "riteway/vitest"; +import { Database } from "bun:sqlite"; +import { createSchema } from "./create-schema.js"; -describe('createSchema()', async () => { +describe("createSchema()", async () => { let db; beforeEach(async () => { // Create in-memory database for fast tests - db = new Database(':memory:'); + db = new Database(":memory:"); }); afterEach(async () => { if (db) db.close(); }); - test('should return version and success status', async () => { + test("should return version and success status", async () => { const result = createSchema(db); assert({ - given: 'schema creation', - should: 'return version 1', + given: "schema creation", + should: "return version 1", actual: result.version, - expected: 1 + expected: 1, }); assert({ - given: 'schema creation', - should: 'indicate tables were created', + given: "schema creation", + should: "indicate tables were created", actual: result.tablesCreated, - expected: true + expected: true, }); }); - test('should create documents table', async () => { + test("should create documents table", async () => { createSchema(db); - const tableInfo = db.prepare(` + const tableInfo = db + .prepare( + ` SELECT name FROM sqlite_master WHERE type='table' AND name='documents' - `).get(); + `, + ) + .get(); assert({ - given: 'schema creation', - should: 'create documents table', + given: "schema creation", + should: "create documents table", actual: tableInfo?.name, - expected: 'documents' + expected: "documents", }); }); - test('should create documents table with correct columns', async () => { + test("should create documents table with correct columns", async () => { createSchema(db); - const columns = db.prepare(` + const columns = db + .prepare( + ` PRAGMA table_info(documents) - `).all(); - - const columnNames = columns.map(c => c.name).sort(); - const expectedColumns = ['path', 'type', 'frontmatter', 'content', 'hash', 'indexed_at', 'file_size', 'modified_at'].sort(); + `, + ) + .all(); + + const columnNames = columns.map((c) => c.name).sort(); + const expectedColumns = [ + "path", + "type", + "frontmatter", + "content", + "hash", + "indexed_at", + "file_size", + "modified_at", + ].sort(); assert({ - given: 'documents table', - should: 'have all required columns', + given: "documents table", + should: "have all required columns", actual: JSON.stringify(columnNames), - expected: JSON.stringify(expectedColumns) + expected: JSON.stringify(expectedColumns), }); }); - test('should create FTS5 virtual table', async () => { + test("should create FTS5 virtual table", async () => { createSchema(db); - const tableInfo = db.prepare(` + const tableInfo = db + .prepare( + ` SELECT name FROM sqlite_master WHERE type='table' AND name='documents_fts' - `).get(); + `, + ) + .get(); assert({ - given: 'schema creation', - should: 'create documents_fts virtual table', + given: "schema creation", + should: "create documents_fts virtual table", actual: tableInfo?.name, - expected: 'documents_fts' + expected: "documents_fts", }); }); - test('should create dependencies table', async () => { + test("should create dependencies table", async () => { createSchema(db); - const tableInfo = db.prepare(` + const tableInfo = db + .prepare( + ` SELECT name FROM sqlite_master WHERE type='table' AND name='dependencies' - `).get(); + `, + ) + .get(); assert({ - given: 'schema creation', - should: 'create dependencies table', + given: "schema creation", + should: "create dependencies table", actual: tableInfo?.name, - expected: 'dependencies' + expected: "dependencies", }); }); - test('should create productmanager tables', async () => { + test("should create productmanager tables", async () => { createSchema(db); - const tables = db.prepare(` + const tables = db + .prepare( + ` SELECT name FROM sqlite_master WHERE type='table' AND name IN ( 'personas', 'journeys', 'journey_personas', 'steps', 'pain_points', 'stories', 'functional_requirements' ) ORDER BY name - `).all(); + `, + ) + .all(); assert({ - given: 'schema creation', - should: 'create all 7 productmanager tables', + given: "schema creation", + should: "create all 7 productmanager tables", actual: tables.length, - expected: 7 + expected: 7, }); }); - test('should create indexes for documents table', async () => { + test("should create indexes for documents table", async () => { createSchema(db); - const indexes = db.prepare(` + const indexes = db + .prepare( + ` SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='documents' - `).all(); + `, + ) + .all(); assert({ - given: 'documents table', - should: 'create at least 3 indexes', + given: "documents table", + should: "create at least 3 indexes", actual: indexes.length >= 3, - expected: true + expected: true, }); }); - test('should enable foreign keys', async () => { + test("should enable foreign keys", async () => { createSchema(db); - const result = db.query('PRAGMA foreign_keys').get(); + const result = db.query("PRAGMA foreign_keys").get(); const fkStatus = result?.foreign_keys; assert({ - given: 'schema creation', - should: 'enable foreign key constraints', + given: "schema creation", + should: "enable foreign key constraints", actual: fkStatus, - expected: 1 + expected: 1, }); }); - test('should record schema version', async () => { + test("should record schema version", async () => { createSchema(db); - const version = db.prepare(` + const version = db + .prepare( + ` SELECT version FROM schema_version WHERE version = 1 - `).get(); + `, + ) + .get(); assert({ - given: 'schema creation', - should: 'record schema version 1', + given: "schema creation", + should: "record schema version 1", actual: version?.version, - expected: 1 + expected: 1, }); }); - test('should create FTS5 triggers', async () => { + test("should create FTS5 triggers", async () => { createSchema(db); - const triggers = db.prepare(` + const triggers = db + .prepare( + ` SELECT name FROM sqlite_master WHERE type='trigger' AND name LIKE 'documents_fts_%' - `).all(); + `, + ) + .all(); assert({ - given: 'schema creation', - should: 'create 3 FTS5 triggers (insert, update, delete)', + given: "schema creation", + should: "create 3 FTS5 triggers (insert, update, delete)", actual: triggers.length, - expected: 3 + expected: 3, }); }); - test('should enforce foreign key constraints', async () => { + test("should enforce foreign key constraints", async () => { createSchema(db); let errorThrown = false; - let errorMessage = ''; + let errorMessage = ""; try { - db.prepare(` + db.prepare( + ` INSERT INTO stories ( id, step_id, name, priority, status, created_at, updated_at ) VALUES ( 'story1', 'nonexistent', 'Test Story', 50, 'backlog', ?, ? ) - `).run(Date.now(), Date.now()); + `, + ).run(Date.now(), Date.now()); } catch (error) { errorThrown = true; errorMessage = error.message; } assert({ - given: 'invalid foreign key', - should: 'throw foreign key constraint error', - actual: errorThrown && errorMessage.includes('FOREIGN KEY'), - expected: true + given: "invalid foreign key", + should: "throw foreign key constraint error", + actual: errorThrown && errorMessage.includes("FOREIGN KEY"), + expected: true, }); }); - test('should be idempotent', async () => { + test("should be idempotent", async () => { createSchema(db); const result2 = createSchema(db); - const versionCount = db.prepare(` + const versionCount = db + .prepare( + ` SELECT COUNT(*) as count FROM schema_version WHERE version = 1 - `).get(); + `, + ) + .get(); assert({ - given: 'multiple schema creation calls', - should: 'not duplicate schema version records', + given: "multiple schema creation calls", + should: "not duplicate schema version records", actual: versionCount.count, - expected: 1 + expected: 1, }); }); - test('should create indexes for dependency traversal', async () => { + test("should create indexes for dependency traversal", async () => { createSchema(db); - const indexes = db.prepare(` + const indexes = db + .prepare( + ` SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='dependencies' ORDER BY name - `).all(); + `, + ) + .all(); - const indexNames = indexes.map(i => i.name); + const indexNames = indexes.map((i) => i.name); assert({ - given: 'dependencies table', - should: 'create index on from_file', - actual: indexNames.includes('idx_dependencies_from'), - expected: true + given: "dependencies table", + should: "create index on from_file", + actual: indexNames.includes("idx_dependencies_from"), + expected: true, }); assert({ - given: 'dependencies table', - should: 'create index on to_file', - actual: indexNames.includes('idx_dependencies_to'), - expected: true + given: "dependencies table", + should: "create index on to_file", + actual: indexNames.includes("idx_dependencies_to"), + expected: true, }); }); - test('should validate pain point impact range', async () => { + test("should validate pain point impact range", async () => { createSchema(db); let errorThrown = false; - let errorMessage = ''; + let errorMessage = ""; try { - db.prepare(` + db.prepare( + ` INSERT INTO pain_points ( id, name, impact, frequency, created_at, updated_at ) VALUES ( 'pp1', 'Test Pain', 15, 5, ?, ? ) - `).run(Date.now(), Date.now()); + `, + ).run(Date.now(), Date.now()); } catch (error) { errorThrown = true; errorMessage = error.message; } assert({ - given: 'impact value > 10', - should: 'enforce CHECK constraint on impact', - actual: errorThrown && errorMessage.includes('CHECK constraint'), - expected: true + given: "impact value > 10", + should: "enforce CHECK constraint on impact", + actual: errorThrown && errorMessage.includes("CHECK constraint"), + expected: true, }); }); - test('should validate story status values', async () => { + test("should validate story status values", async () => { createSchema(db); let errorThrown = false; - let errorMessage = ''; + let errorMessage = ""; - try{ - db.prepare(` + try { + db.prepare( + ` INSERT INTO stories ( id, name, status, priority, created_at, updated_at ) VALUES ( 'story1', 'Test', 'invalid_status', 50, ?, ? ) - `).run(Date.now(), Date.now()); + `, + ).run(Date.now(), Date.now()); } catch (error) { errorThrown = true; errorMessage = error.message; } assert({ - given: 'invalid status value', - should: 'enforce CHECK constraint on status', - actual: errorThrown && errorMessage.includes('CHECK constraint'), - expected: true + given: "invalid status value", + should: "enforce CHECK constraint on status", + actual: errorThrown && errorMessage.includes("CHECK constraint"), + expected: true, }); }); });