{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-dyoshikawa--rulesync","slug":"dyoshikawa--rulesync","name":"rulesync","type":"cli","url":"http://rulesync.dyoshikawa.com/","page_url":"https://unfragile.ai/dyoshikawa--rulesync","categories":["cli-tools"],"tags":["ai","ai-agents","ai-coding","llm","mcp","rules","skills"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-dyoshikawa--rulesync__cap_0","uri":"capability://tool.use.integration.unified.configuration.synchronization.across.multiple.ai.coding.assistants","name":"unified configuration synchronization across multiple ai coding assistants","description":"Maintains a single source of truth in .rulesync/ directory and bidirectionally converts configurations to tool-specific formats (Claude Code, Cursor, GitHub Copilot, CLI tools) using a factory pattern with tool registries and feature processors. Implements configuration resolution with priority ordering and schema validation to prevent drift across heterogeneous AI development environments.","intents":["I want to maintain one set of rules and have them automatically sync to all my AI coding tools without manual duplication","I need to ensure configuration consistency across Claude Code, Cursor, and GitHub Copilot without managing separate .cursorrules and CLAUDE.md files","I want to update AI assistant rules once and have changes propagate to all integrated tools automatically"],"best_for":["teams using multiple AI coding assistants (Claude Code, Cursor, GitHub Copilot) simultaneously","developers managing monorepos with per-target feature configuration requirements","organizations needing configuration governance and preventing tool-specific configuration drift"],"limitations":["Bidirectional conversion pattern may lose tool-specific optimizations when converting back to canonical format","Per-target feature configuration adds complexity to configuration resolution priority ordering","Global mode requires careful management to avoid unintended cross-project configuration pollution"],"requires":["Node.js 18+","TypeScript runtime for CLI execution",".rulesync/ directory initialized in project root or global location","Target AI tool installed (Claude Code, Cursor, GitHub Copilot, or CLI)"],"input_types":["markdown files (rules, commands, skills, subagents)","JSON configuration (mcp.json, permissions.json)","YAML/TOML frontmatter with schema validation"],"output_types":["tool-specific configuration files (.cursorrules, CLAUDE.md, .github/copilot-instructions.md)","MCP server configuration","CLI command definitions","structured JSON for tool registries"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-dyoshikawa--rulesync__cap_1","uri":"capability://tool.use.integration.feature.processor.architecture.for.modular.configuration.transformation","name":"feature processor architecture for modular configuration transformation","description":"Implements a processor-based architecture (RulesProcessor, IgnoreProcessor, McpProcessor, CommandsProcessor, SubagentsProcessor, SkillsProcessor, HooksProcessor, PermissionsProcessor) that transforms unified file formats into tool-specific outputs. Each processor handles a distinct feature type with independent validation, transformation logic, and tool-specific conversion patterns, enabling extensibility without modifying core synchronization logic.","intents":["I want to add support for a new AI tool without rewriting the entire configuration system","I need to validate that my rules, commands, and skills conform to expected schemas before deploying","I want to extend rulesync with custom feature types that map to my specific tool ecosystem"],"best_for":["developers extending rulesync with new feature types or tool integrations","teams implementing custom processors for proprietary AI tools","projects requiring per-feature validation and transformation logic"],"limitations":["Adding new feature types requires implementing processor interface and tool-specific conversion patterns","Processor architecture adds abstraction layers that may introduce ~50-100ms overhead per feature transformation","Tool-specific implementations must be maintained separately for each supported AI assistant"],"requires":["TypeScript 4.5+","Understanding of processor interface contract","Knowledge of target tool's configuration format and API","Schema definition for new feature type"],"input_types":["markdown with YAML/TOML frontmatter","JSON configuration files","structured text with schema validation"],"output_types":["tool-specific configuration files","validation reports","transformation logs"],"categories":["tool-use-integration","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-dyoshikawa--rulesync__cap_10","uri":"capability://text.generation.language.rules.and.guidelines.synchronization.with.markdown.frontmatter","name":"rules and guidelines synchronization with markdown frontmatter","description":"Synchronizes rules and guidelines (RulesProcessor) defined in markdown files with YAML/TOML frontmatter metadata to tool-specific formats (Claude Code, Cursor, GitHub Copilot instruction files). Supports rule organization, versioning, and tool-specific rule variants, enabling developers to maintain human-readable rule documentation that automatically syncs to AI assistants.","intents":["I want to write rules in markdown and have them automatically sync to my AI assistant's instruction files","I need to maintain version-controlled rule documentation that stays in sync with tool-specific configurations","I want to define tool-specific rule variants without duplicating rule content"],"best_for":["teams maintaining comprehensive AI assistant guidelines in version control","projects requiring human-readable rule documentation alongside tool configurations","organizations standardizing AI coding practices across teams"],"limitations":["Markdown to tool-specific format conversion may lose formatting or structure","Frontmatter metadata adds complexity to rule authoring and validation","Tool-specific rule length limits may require rule truncation or summarization"],"requires":["rules.md or rules/ directory with markdown files","YAML/TOML frontmatter with metadata (tool targets, versions, etc.)","schema validation for frontmatter structure"],"input_types":["markdown files with YAML/TOML frontmatter","rule metadata (name, description, tool targets, versions)","rule content in markdown format"],"output_types":["tool-specific instruction files (.cursorrules, CLAUDE.md, .github/copilot-instructions.md)","rule documentation with metadata","version-controlled rule history"],"categories":["text-generation-language","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-dyoshikawa--rulesync__cap_11","uri":"capability://safety.moderation.ignore.patterns.and.file.exclusion.with.tool.specific.semantics","name":"ignore patterns and file exclusion with tool-specific semantics","description":"Manages ignore patterns (IgnoreProcessor) that exclude files and directories from AI assistant context using tool-specific semantics (.gitignore, .cursorrules ignore syntax, GitHub Copilot exclusions). Supports pattern inheritance, negation rules, and tool-specific ignore file generation, enabling developers to control which files AI assistants can access without duplicating ignore patterns.","intents":["I want to define ignore patterns once and have them applied to all my AI tools","I need to exclude sensitive files from AI assistant context without managing separate ignore files","I want to use .gitignore patterns for AI tools but also define tool-specific exclusions"],"best_for":["teams managing sensitive files that should be excluded from AI assistant context","projects with large codebases where controlling AI context is critical","organizations enforcing data privacy policies on AI tool usage"],"limitations":["Tool-specific ignore semantics may differ (e.g., .gitignore vs Cursor ignore syntax)","Ignore pattern inheritance and negation rules add complexity to pattern resolution","Some tools may not support all ignore pattern features (e.g., negation, complex patterns)"],"requires":["ignore.md or ignore.json with ignore pattern definitions","understanding of tool-specific ignore syntax for each target AI assistant","schema validation for ignore pattern format"],"input_types":["ignore pattern definitions (glob patterns, negation rules, tool-specific syntax)","tool-specific ignore requirements",".gitignore patterns (optional inheritance)"],"output_types":["tool-specific ignore files (.cursorrules ignore, GitHub Copilot exclusions)","ignore pattern validation reports","pattern inheritance resolution"],"categories":["safety-moderation","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-dyoshikawa--rulesync__cap_12","uri":"capability://safety.moderation.schema.validation.and.configuration.type.checking","name":"schema validation and configuration type checking","description":"Implements schema validation for all configuration file formats (rules, commands, skills, subagents, MCP, ignore, hooks, permissions) using JSON Schema with frontmatter validation. Validates configuration structure, data types, and required fields before processing, catching configuration errors early and providing detailed validation error messages to guide developers.","intents":["I want to validate my configuration files before deploying them to ensure they're correct","I need detailed error messages when my configuration has schema violations","I want to catch configuration mistakes early in development rather than at runtime"],"best_for":["teams implementing strict configuration validation in CI/CD pipelines","projects requiring configuration governance and compliance","developers new to rulesync who need guidance on correct configuration format"],"limitations":["Schema validation cannot detect semantic errors (e.g., invalid tool names, missing dependencies)","Complex schema definitions may be difficult to understand and maintain","Validation error messages may be verbose or unclear for complex schema violations"],"requires":["JSON Schema definitions for all feature types","schema validation library (e.g., ajv)","configuration files conforming to schema definitions"],"input_types":["configuration files (rules.md, commands.json, skills.md, etc.)","frontmatter metadata (YAML/TOML)","JSON configuration files"],"output_types":["validation reports with error details","schema violation messages","validation success/failure status"],"categories":["safety-moderation","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-dyoshikawa--rulesync__cap_13","uri":"capability://automation.workflow.github.workflow.automation.and.ci.cd.integration","name":"github workflow automation and ci/cd integration","description":"Provides GitHub Actions workflow templates and CI/CD integration patterns for automated configuration validation, synchronization, and deployment. Enables developers to integrate rulesync into GitHub workflows for pre-commit validation, automated synchronization on configuration changes, and deployment to production environments.","intents":["I want to automatically validate my rulesync configuration in GitHub Actions before merging","I need to automatically sync configuration changes to all AI tools when I push to main branch","I want to prevent invalid configurations from being deployed to production"],"best_for":["teams using GitHub for version control and CI/CD","projects requiring automated configuration validation and deployment","organizations enforcing configuration governance through CI/CD pipelines"],"limitations":["GitHub Actions integration requires GitHub repository and Actions enabled","Workflow templates may need customization for specific project requirements","CI/CD latency adds delay to configuration synchronization (typically 1-5 minutes)"],"requires":["GitHub repository with Actions enabled","GitHub Actions workflow files (.github/workflows/)","rulesync CLI available in workflow environment"],"input_types":["GitHub Actions workflow definitions","configuration file changes (push events)","pull request events"],"output_types":["workflow execution logs","validation reports","deployment status"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-dyoshikawa--rulesync__cap_14","uri":"capability://data.processing.analysis.import.and.export.functionality.for.configuration.migration","name":"import and export functionality for configuration migration","description":"Provides import and export commands (import, export) that enable migration from existing tool-specific configurations (.cursorrules, CLAUDE.md, .github/copilot-instructions.md) to unified rulesync format and vice versa. Supports bidirectional conversion with conflict detection and merge strategies, enabling gradual migration from tool-specific to unified configuration management.","intents":["I want to migrate my existing .cursorrules and CLAUDE.md files to rulesync format","I need to export my rulesync configuration back to tool-specific formats for compatibility","I want to gradually migrate from tool-specific configurations to unified rulesync management"],"best_for":["teams migrating from tool-specific configuration management to rulesync","projects requiring backward compatibility with existing tool-specific configurations","organizations with legacy configurations that need to be unified"],"limitations":["Import may lose tool-specific optimizations or features not supported by rulesync format","Bidirectional conversion may introduce subtle differences in configuration semantics","Conflict detection and merge strategies add complexity to migration process"],"requires":["existing tool-specific configuration files (.cursorrules, CLAUDE.md, etc.)","rulesync CLI with import/export commands","understanding of configuration format differences"],"input_types":["tool-specific configuration files (.cursorrules, CLAUDE.md, .github/copilot-instructions.md)","rulesync configuration format","merge strategy specifications"],"output_types":["rulesync format configuration files","tool-specific configuration files","migration reports with conflict information"],"categories":["data-processing-analysis","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-dyoshikawa--rulesync__cap_15","uri":"capability://automation.workflow.fetch.and.install.commands.for.remote.configuration.sources","name":"fetch and install commands for remote configuration sources","description":"Implements fetch and install commands that retrieve rules, skills, and commands from remote sources (HTTP, Git, local filesystem) with lockfile management and version pinning. Supports multiple transport implementations, dependency resolution, and install modes (copy, symlink, reference), enabling centralized configuration distribution and version management.","intents":["I want to fetch rules from a central repository and keep them in sync with version control","I need to install skills from multiple sources with version pinning and dependency resolution","I want to manage configuration dependencies declaratively without manual downloads"],"best_for":["organizations distributing shared rules and skills across multiple projects","teams managing centralized configuration repositories with version control","projects requiring dependency management for configuration artifacts"],"limitations":["Fetch process adds network latency (varies by transport and source location)","Lockfile management adds complexity to version control and conflict resolution","Multiple transport implementations require separate maintenance for each transport type"],"requires":["fetch and install commands in rulesync CLI","declarative sources definition (JSON/YAML)","network access for remote sources (if using HTTP/HTTPS)","Git installed (if using Git transport)"],"input_types":["declarative sources definition with URLs and version specifications","transport specifications (HTTP, Git, local filesystem)","install mode preferences (copy, symlink, reference)"],"output_types":["fetched configuration files","lockfile with pinned versions","installation status and logs"],"categories":["automation-workflow","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-dyoshikawa--rulesync__cap_2","uri":"capability://tool.use.integration.mcp.server.integration.with.declarative.tool.configuration","name":"mcp server integration with declarative tool configuration","description":"Exposes rulesync as an MCP server with tools for managing rules, commands, skills, and subagents through a standardized MCP interface. Supports declarative sources declaration with lockfile management, fetch process with multiple transports, and install modes, enabling AI agents to dynamically discover and invoke rulesync capabilities without direct CLI access.","intents":["I want my AI agent to be able to fetch and install rules from remote sources without manual intervention","I need to expose rulesync capabilities to Claude or other MCP-compatible agents as a server","I want to manage dependencies and versions for rules, commands, and skills declaratively"],"best_for":["AI agents (Claude, Cursor, etc.) that need to interact with rulesync programmatically","teams distributing rules and skills across multiple projects via MCP","organizations managing centralized rule repositories with version control"],"limitations":["MCP server requires separate process management and lifecycle handling","Declarative sources add complexity to dependency resolution and lockfile management","Transport layer abstraction may add latency for remote source fetching (varies by transport implementation)"],"requires":["MCP-compatible client (Claude, Cursor, or custom implementation)","Node.js 18+ for MCP server process","Network access for remote source fetching (if using HTTP/HTTPS transport)",".rulesync/mcp.json configuration file"],"input_types":["MCP tool invocation requests","declarative source definitions (JSON/YAML)","remote URLs for rules/skills/commands"],"output_types":["MCP tool responses","lockfile updates","installed configuration artifacts"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-dyoshikawa--rulesync__cap_3","uri":"capability://automation.workflow.project.and.global.mode.configuration.with.monorepo.support","name":"project and global mode configuration with monorepo support","description":"Supports both project-scoped (.rulesync/ in project root) and global-scoped (user home directory) configuration modes with explicit monorepo support through per-target feature configuration. Configuration resolution follows priority ordering (project > global) and validates path security to prevent directory traversal attacks, enabling flexible deployment across single projects and complex monorepo structures.","intents":["I want to define global AI rules that apply to all my projects but override them per-project when needed","I need to manage rules for multiple packages in a monorepo with per-package customization","I want to ensure that global configuration doesn't accidentally affect unintended projects"],"best_for":["developers working across multiple projects with shared baseline rules","monorepo maintainers needing per-package AI assistant configuration","organizations establishing company-wide AI coding standards with project-level overrides"],"limitations":["Global mode requires careful management to avoid unintended cross-project configuration pollution","Configuration resolution priority ordering adds complexity to debugging configuration sources","Monorepo support requires explicit per-target feature configuration, increasing configuration file size"],"requires":["Node.js 18+","Write access to project root (.rulesync/) or home directory (~/.rulesync/)","Understanding of configuration resolution priority (project > global)"],"input_types":["project-scoped .rulesync/ directory","global ~/.rulesync/ directory","per-target configuration overrides"],"output_types":["resolved configuration (merged project + global)","tool-specific outputs per target","validation reports showing configuration source"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-dyoshikawa--rulesync__cap_4","uri":"capability://data.processing.analysis.ai.file.and.directory.abstraction.with.semantic.path.resolution","name":"ai file and directory abstraction with semantic path resolution","description":"Provides AiFile and AiDir abstractions that encapsulate semantic path resolution, file system operations, and tool-specific path handling. Abstractions normalize paths across different operating systems and tool conventions, enabling processors to work with logical file references without managing tool-specific path formats or OS-specific path separators.","intents":["I want to reference files in my rules without worrying about OS-specific path separators or tool conventions","I need to resolve relative paths consistently across different AI tools and operating systems","I want to abstract away tool-specific path handling so processors can focus on transformation logic"],"best_for":["processor implementations that need consistent path handling across tools","cross-platform projects targeting Windows, macOS, and Linux","teams using tools with different path conventions (e.g., Cursor vs GitHub Copilot)"],"limitations":["Abstraction adds indirection layer that may obscure tool-specific path requirements","Semantic path resolution may not handle all edge cases in complex monorepo structures","OS-specific behavior differences (case sensitivity on macOS vs Windows) require explicit handling"],"requires":["TypeScript 4.5+","Understanding of AiFile and AiDir interface contracts","Knowledge of target tool's path conventions"],"input_types":["relative file paths","absolute file paths","tool-specific path formats"],"output_types":["normalized file references","OS-agnostic path strings","tool-specific path formats"],"categories":["data-processing-analysis","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-dyoshikawa--rulesync__cap_5","uri":"capability://safety.moderation.permissions.based.access.control.for.ai.tool.capabilities","name":"permissions-based access control for ai tool capabilities","description":"Implements a permissions system (PermissionsProcessor) that defines granular access control for AI tool capabilities through declarative permissions format. Validates tool-specific permission requirements and enforces access control policies, preventing unauthorized tool invocations and ensuring compliance with security policies defined in permissions configuration.","intents":["I want to restrict which AI tools can access certain commands or capabilities in my project","I need to enforce security policies that prevent specific AI assistants from executing sensitive operations","I want to define granular permissions that vary by tool, project, or feature type"],"best_for":["teams with security-sensitive projects requiring tool capability restrictions","organizations enforcing compliance policies on AI assistant usage","projects where different tools should have different capability access levels"],"limitations":["Permissions system adds validation overhead (~50-100ms per permission check)","Tool-specific permission implementations must be maintained separately for each supported tool","Granular permissions increase configuration complexity and potential for misconfiguration"],"requires":["permissions.json configuration file with schema validation","Tool-specific permission implementations for each target AI assistant","Understanding of permission model and access control policies"],"input_types":["permissions.json with declarative access control rules","tool-specific permission requirements","feature type and capability identifiers"],"output_types":["validated permission policies","access control decisions (allow/deny)","permission validation reports"],"categories":["safety-moderation","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-dyoshikawa--rulesync__cap_6","uri":"capability://automation.workflow.dry.run.and.check.modes.for.configuration.validation.without.side.effects","name":"dry-run and check modes for configuration validation without side effects","description":"Provides dry-run and check modes that validate configuration transformations and synchronization without modifying files or executing side effects. Enables developers to preview configuration changes, validate schema compliance, and detect conflicts before committing changes to tool-specific configuration files or executing hooks.","intents":["I want to preview what configuration changes will be made before actually applying them","I need to validate that my rules and commands are syntactically correct without modifying files","I want to detect configuration conflicts or validation errors before deploying to production"],"best_for":["developers validating configuration changes in CI/CD pipelines","teams implementing pre-commit hooks to prevent invalid configurations","projects requiring configuration review before deployment"],"limitations":["Dry-run mode cannot detect runtime errors that only occur during actual tool execution","Check mode validation is limited to schema compliance and cannot verify tool-specific behavior","Dry-run output may not accurately reflect all side effects (e.g., hook execution, external API calls)"],"requires":["rulesync CLI with --dry-run or --check flags","valid .rulesync/ configuration directory","schema definitions for all feature types"],"input_types":["configuration files in .rulesync/ directory","feature type definitions","tool-specific conversion rules"],"output_types":["validation reports","preview of configuration changes","error messages for schema violations"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-dyoshikawa--rulesync__cap_7","uri":"capability://automation.workflow.hooks.system.for.custom.configuration.lifecycle.management","name":"hooks system for custom configuration lifecycle management","description":"Implements a hooks system (HooksProcessor) that executes custom scripts at defined lifecycle points (pre-sync, post-sync, pre-generate, post-generate) enabling integration with external tools and custom validation logic. Hooks are defined declaratively in hooks format and executed in isolated contexts with access to configuration state and environment variables.","intents":["I want to run custom validation or formatting scripts after configuration is generated","I need to integrate rulesync with external tools (linters, formatters, deployment systems) in my workflow","I want to execute setup or cleanup operations before and after configuration synchronization"],"best_for":["teams integrating rulesync with custom CI/CD pipelines or build systems","projects requiring post-generation validation or formatting","organizations with complex configuration workflows requiring orchestration"],"limitations":["Hooks add execution overhead and complexity to configuration lifecycle","Hook failures can block configuration synchronization if not handled carefully","Debugging hook execution requires access to hook logs and environment state","Hook scripts must be maintained separately and may have language-specific dependencies"],"requires":["hooks.json configuration file with hook definitions","executable scripts or commands for each hook","environment variables and configuration state accessible to hooks"],"input_types":["hooks.json with lifecycle hook definitions","executable scripts (shell, Node.js, Python, etc.)","configuration state and environment variables"],"output_types":["hook execution logs","exit codes and error messages","modified configuration state (if hooks modify files)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-dyoshikawa--rulesync__cap_8","uri":"capability://tool.use.integration.cli.command.generation.and.management.with.tool.specific.syntax","name":"cli command generation and management with tool-specific syntax","description":"Generates and manages CLI commands (CommandsProcessor) that are converted to tool-specific formats (Claude Code, Cursor, GitHub Copilot command palettes). Supports command metadata (name, description, arguments), tool-specific syntax variations, and integration with AI assistant command execution systems, enabling developers to expose custom commands through AI tools.","intents":["I want to define custom commands that appear in my AI assistant's command palette","I need to expose project-specific CLI commands to Claude Code, Cursor, and GitHub Copilot","I want to manage command definitions in a tool-agnostic format and have them automatically converted to tool-specific syntax"],"best_for":["developers exposing custom CLI commands to AI assistants","teams standardizing command definitions across multiple AI tools","projects with complex command workflows that need AI assistant integration"],"limitations":["Tool-specific command syntax variations require separate implementations for each AI assistant","Command argument handling and validation varies by tool, requiring tool-specific conversion logic","Some tools may not support all command features (e.g., complex argument types, environment variables)"],"requires":["commands.json or commands.md with command definitions","tool-specific command syntax knowledge for target AI assistants","CLI commands available in project or accessible via PATH"],"input_types":["command definitions (name, description, arguments, execution context)","tool-specific command syntax requirements","environment variables and execution context"],"output_types":["tool-specific command definitions","command palette entries","command execution logs"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-dyoshikawa--rulesync__cap_9","uri":"capability://planning.reasoning.subagents.and.skills.management.for.ai.agent.composition","name":"subagents and skills management for ai agent composition","description":"Manages subagents and skills (SubagentsProcessor, SkillsProcessor) that enable AI agents to delegate tasks to specialized agents or invoke reusable skill implementations. Supports skill definitions with metadata, parameter schemas, and execution contexts, enabling composition of complex AI workflows through declarative skill and subagent definitions.","intents":["I want to define reusable skills that my AI agent can invoke for common tasks","I need to delegate specific tasks to specialized subagents without hardcoding agent logic","I want to manage skill definitions and subagent configurations in a centralized, version-controlled location"],"best_for":["teams building complex AI agent workflows with task delegation","organizations managing libraries of reusable skills across multiple projects","projects requiring specialized subagents for domain-specific tasks"],"limitations":["Subagent delegation adds latency and complexity to agent workflows","Skill parameter schemas require careful design to avoid over-specification or under-specification","Subagent orchestration requires explicit error handling and retry logic"],"requires":["subagents.json or subagents.md with subagent definitions","skills.json or skills.md with skill definitions and parameter schemas","AI agent framework supporting subagent delegation (Claude, custom agents)"],"input_types":["subagent definitions (name, description, capabilities, execution context)","skill definitions (name, description, parameters, implementation)","parameter schemas for skill invocation"],"output_types":["subagent configurations","skill definitions with metadata","parameter validation schemas"],"categories":["planning-reasoning","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":41,"verified":false,"data_access_risk":"high","permissions":["Node.js 18+","TypeScript runtime for CLI execution",".rulesync/ directory initialized in project root or global location","Target AI tool installed (Claude Code, Cursor, GitHub Copilot, or CLI)","TypeScript 4.5+","Understanding of processor interface contract","Knowledge of target tool's configuration format and API","Schema definition for new feature type","rules.md or rules/ directory with markdown files","YAML/TOML frontmatter with metadata (tool targets, versions, etc.)"],"failure_modes":["Bidirectional conversion pattern may lose tool-specific optimizations when converting back to canonical format","Per-target feature configuration adds complexity to configuration resolution priority ordering","Global mode requires careful management to avoid unintended cross-project configuration pollution","Adding new feature types requires implementing processor interface and tool-specific conversion patterns","Processor architecture adds abstraction layers that may introduce ~50-100ms overhead per feature transformation","Tool-specific implementations must be maintained separately for each supported AI assistant","Markdown to tool-specific format conversion may lose formatting or structure","Frontmatter metadata adds complexity to rule authoring and validation","Tool-specific rule length limits may require rule truncation or summarization","Tool-specific ignore semantics may differ (e.g., .gitignore vs Cursor ignore syntax)","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.4299722536927605,"quality":0.35,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.28,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:21.550Z","last_scraped_at":"2026-05-03T13:58:34.540Z","last_commit":"2026-05-01T05:39:56Z"},"community":{"stars":1064,"forks":108,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=dyoshikawa--rulesync","compare_url":"https://unfragile.ai/compare?artifact=dyoshikawa--rulesync"}},"signature":"I5xJP6XHtfYyX/lDa4xkY3gDQWU63s80+ctO2Ml5cyuMEHCzTrsDDKilXyIKWya9KyqNcDfE4idSMa2nglT1Cw==","signedAt":"2026-06-20T18:36:45.237Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/dyoshikawa--rulesync","artifact":"https://unfragile.ai/dyoshikawa--rulesync","verify":"https://unfragile.ai/api/v1/verify?slug=dyoshikawa--rulesync","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}