@agentlee5/agent-skills 1.0.0

package/LeeWay-Standards/src/core/tag-validator.js

@@ -0,0 +1,139 @@
+/*
+LEEWAY HEADER — DO NOT REMOVE
+
+REGION: CORE.SDK.VALIDATOR
+TAG: CORE.SDK.TAG.VALIDATOR
+
+COLOR_ONION_HEX:
+NEON=#39FF14
+FLUO=#0DFF94
+PASTEL=#C7FFD8
+
+ICON_ASCII:
+family=lucide
+glyph=tag
+
+5WH:
+WHAT = Validates and infers LEEWAY TAG values for files
+WHY = Every file needs a structured TAG to be discoverable and machine-readable
+WHO = Rapid Web Development
+WHERE = src/core/tag-validator.js
+WHEN = 2026
+HOW = Pattern matching against known domain/subdomain/asset/purpose vocabulary
+
+AGENTS:
+TAG
+ASSESS
+
+LICENSE:
+MIT
+*/
+
+const TAG_DOMAINS = ['UI', 'CORE', 'DATA', 'AI', 'SEO', 'UTIL', 'MCP', 'SECURITY', 'TEST', 'DOCS'];
+
+const DOMAIN_SUBDOMAINS = {
+  UI: ['COMPONENT', 'PAGE', 'LAYOUT', 'HOOK', 'CONTEXT', 'STYLE', 'THEME'],
+  CORE: ['SDK', 'ENGINE', 'RUNTIME', 'CONFIG', 'SCHEMA', 'REGISTRY'],
+  DATA: ['LOCAL', 'REMOTE', 'STORE', 'CACHE', 'MODEL', 'MIGRATION'],
+  AI: ['ORCHESTRATION', 'MODEL', 'PROMPT', 'ROUTER', 'AGENT', 'MEMORY'],
+  SEO: ['SCHEMA', 'META', 'SITEMAP', 'GENERATOR', 'DISCOVERY'],
+  UTIL: ['FORMAT', 'DATE', 'STRING', 'MATH', 'CRYPTO', 'LOGGER', 'HELPER'],
+  MCP: ['TRANSPORT', 'ENDPOINT', 'PORT', 'PROCESS', 'MANIFEST', 'HEALTH'],
+  SECURITY: ['SCANNER', 'POLICY', 'PERMISSION', 'VALIDATOR', 'AUDIT'],
+  TEST: ['UNIT', 'INTEGRATION', 'E2E', 'FIXTURE', 'MOCK'],
+  DOCS: ['STANDARD', 'GUIDE', 'SCHEMA', 'REPORT', 'EXAMPLE'],
+};
+
+/**
+ * Validate a LEEWAY TAG string.
+ * Format: DOMAIN.SUBDOMAIN.ASSET.PURPOSE (minimum 3 parts)
+ *
+ * @param {string} tag
+ * @returns {{ valid: boolean, errors: string[] }}
+ */
+export function validateTag(tag) {
+  const errors = [];
+
+  if (!tag || typeof tag !== 'string') {
+    return { valid: false, errors: ['TAG must be a non-empty string'] };
+  }
+
+  const parts = tag.toUpperCase().split('.');
+  if (parts.length < 3) {
+    errors.push('TAG must have at least 3 parts: DOMAIN.SUBDOMAIN.ASSET');
+  }
+
+  const [domain, subdomain] = parts;
+
+  if (!TAG_DOMAINS.includes(domain)) {
+    errors.push(`Unknown TAG domain "${domain}". Valid: ${TAG_DOMAINS.join(', ')}`);
+  } else if (subdomain && DOMAIN_SUBDOMAINS[domain]) {
+    if (!DOMAIN_SUBDOMAINS[domain].includes(subdomain)) {
+      errors.push(`Unknown subdomain "${subdomain}" for domain "${domain}". Valid: ${DOMAIN_SUBDOMAINS[domain].join(', ')}`);
+    }
+  }
+
+  const tagPattern = /^[A-Z][A-Z0-9]*(\.[A-Z][A-Z0-9]*)+$/;
+  if (!tagPattern.test(tag)) {
+    errors.push('TAG must use UPPERCASE.DOT.NOTATION with alphanumeric segments');
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+/**
+ * Infer a LEEWAY TAG from a file path and optional context.
+ *
+ * @param {string} filePath - Relative or absolute file path
+ * @param {{ purpose?: string, name?: string }} [context]
+ * @returns {string} - Inferred TAG string
+ */
+export function inferTag(filePath, context = {}) {
+  const path = filePath.toLowerCase().replace(/\\/g, '/');
+  const normalizedOriginal = filePath.replace(/\\/g, '/');
+  const originalSegments = normalizedOriginal.split('/').filter(Boolean);
+  const originalFileName = originalSegments[originalSegments.length - 1] || '';
+  const segments = path.split('/').filter(Boolean);
+  const fileName = segments[segments.length - 1] || '';
+  const baseName = fileName.replace(/\.[^.]+$/, '').toUpperCase().replace(/[^A-Z0-9]/g, '_');
+  const purpose = (context.purpose || 'MAIN').toUpperCase().replace(/[^A-Z0-9]/g, '_');
+
+  if (path.includes('/components/') || path.includes('/ui/')) {
+    return `UI.COMPONENT.${baseName}.${purpose}`;
+  }
+  if (path.includes('/pages/') || path.includes('/page/')) {
+    return `UI.PAGE.${baseName}.${purpose}`;
+  }
+  if (path.includes('/hooks/') || /^use[A-Z]/.test(originalFileName)) {
+    return `UI.HOOK.${baseName}.${purpose}`;
+  }
+  if (path.includes('/agents/')) {
+    return `AI.AGENT.${baseName}.${purpose}`;
+  }
+  if (path.includes('/ai/') || path.includes('/llm/')) {
+    return `AI.ORCHESTRATION.${baseName}.${purpose}`;
+  }
+  if (path.includes('/data/') || path.includes('/store/') || path.includes('/db/')) {
+    return `DATA.STORE.${baseName}.${purpose}`;
+  }
+  if (path.includes('/security/') || path.includes('/auth/')) {
+    return `SECURITY.VALIDATOR.${baseName}.${purpose}`;
+  }
+  if (path.includes('/seo/') || path.includes('/discovery/') || path.includes('/schema/')) {
+    return `SEO.SCHEMA.${baseName}.${purpose}`;
+  }
+  if (path.includes('/utils/') || path.includes('/helpers/') || path.includes('/util/')) {
+    return `UTIL.HELPER.${baseName}.${purpose}`;
+  }
+  if (path.includes('/mcp/') || path.includes('/transport/')) {
+    return `MCP.TRANSPORT.${baseName}.${purpose}`;
+  }
+  if (path.includes('/core/') || path.includes('/sdk/')) {
+    return `CORE.SDK.${baseName}.${purpose}`;
+  }
+  if (path.includes('/docs/') || path.includes('/documentation/')) {
+    return `DOCS.STANDARD.${baseName}.${purpose}`;
+  }
+
+  return `CORE.SDK.${baseName}.${purpose}`;
+}

package/LeeWay-Standards/src/core/tag-validator.test.js

@@ -0,0 +1,109 @@
+/*
+LEEWAY HEADER — DO NOT REMOVE
+
+REGION: TEST.CORE.TAG
+TAG: TEST.UNIT.TAG.VALIDATOR
+
+COLOR_ONION_HEX:
+NEON=#39FF14
+FLUO=#0DFF94
+PASTEL=#C7FFD8
+
+ICON_ASCII:
+family=lucide
+glyph=test-tube
+
+5WH:
+WHAT = Unit tests for the LEEWAY tag-validator core module
+WHY = TAG validation is critical — invalid tags break discoverability and governance
+WHO = Rapid Web Development
+WHERE = src/core/tag-validator.test.js
+WHEN = 2026
+HOW = Node.js built-in test runner (node:test) with assert
+
+AGENTS:
+AUDIT
+
+LICENSE:
+MIT
+*/
+
+import { test, describe } from 'node:test';
+import assert from 'node:assert/strict';
+import { validateTag, inferTag } from './tag-validator.js';
+
+describe('validateTag', () => {
+  test('validates a correct tag', () => {
+    const { valid, errors } = validateTag('UI.COMPONENT.NEXUS.BUTTON');
+    assert.equal(valid, true);
+    assert.equal(errors.length, 0);
+  });
+
+  test('rejects a tag with too few parts', () => {
+    const { valid, errors } = validateTag('UI.COMPONENT');
+    assert.equal(valid, false);
+    assert.ok(errors.some(e => e.includes('3 parts')));
+  });
+
+  test('rejects an empty tag', () => {
+    const { valid } = validateTag('');
+    assert.equal(valid, false);
+  });
+
+  test('rejects null tag', () => {
+    const { valid } = validateTag(null);
+    assert.equal(valid, false);
+  });
+
+  test('rejects lowercase tag', () => {
+    const { valid } = validateTag('ui.component.button');
+    assert.equal(valid, false);
+  });
+
+  test('validates multi-part tags', () => {
+    const tags = [
+      'AI.ORCHESTRATION.MODEL.LOADER',
+      'DATA.LOCAL.STORE.MAIN',
+      'SEO.SCHEMA.GENERATOR.JSONLD',
+      'UTIL.FORMAT.DATE.HELPER',
+      'CORE.SDK.HEADER.PARSER',
+    ];
+    for (const tag of tags) {
+      const { valid, errors } = validateTag(tag);
+      assert.equal(valid, true, `Tag "${tag}" should be valid. Errors: ${errors.join(', ')}`);
+    }
+  });
+});
+
+describe('inferTag', () => {
+  test('infers UI tag for component path', () => {
+    const tag = inferTag('src/components/NexusButton.tsx');
+    assert.ok(tag.startsWith('UI.COMPONENT.'));
+  });
+
+  test('infers AI tag for agent path', () => {
+    const tag = inferTag('src/agents/assess-agent.js');
+    assert.ok(tag.startsWith('AI.AGENT.'));
+  });
+
+  test('infers DATA tag for store path', () => {
+    const tag = inferTag('src/store/userStore.js');
+    assert.ok(tag.startsWith('DATA.STORE.'));
+  });
+
+  test('infers UTIL tag for utils path', () => {
+    const tag = inferTag('src/utils/formatDate.js');
+    assert.ok(tag.startsWith('UTIL.HELPER.'));
+  });
+
+  test('infers SECURITY tag for auth path', () => {
+    const tag = inferTag('src/auth/validator.js');
+    assert.ok(tag.startsWith('SECURITY.VALIDATOR.'));
+  });
+
+  test('returns fallback for unknown paths', () => {
+    const tag = inferTag('src/unknown/something.js');
+    assert.ok(typeof tag === 'string');
+    assert.ok(tag.length > 0);
+  });
+});

package/LeeWay-Standards/src/index.js

@@ -0,0 +1,83 @@
+/*
+LEEWAY HEADER — DO NOT REMOVE
+
+REGION: CORE.SDK.ENTRY
+TAG: CORE.SDK.LEEWAY.INDEX
+
+COLOR_ONION_HEX:
+NEON=#39FF14
+FLUO=#0DFF94
+PASTEL=#C7FFD8
+
+ICON_ASCII:
+family=lucide
+glyph=layers
+
+5WH:
+WHAT = LEEWAY SDK main entry point — exports all agents, core modules, and utilities
+WHY = Provides a single importable surface for consumers of the LEEWAY governance framework
+WHO = Rapid Web Development
+WHERE = src/index.js
+WHEN = 2026
+HOW = ESM exports, lazy agent loading, zero heavy dependencies
+
+AGENTS:
+ASSESS
+ALIGN
+AUDIT
+
+LICENSE:
+MIT
+*/
+
+export { parseHeader, buildHeader, validateHeader } from './core/header-parser.js';
+export { validateTag, inferTag } from './core/tag-validator.js';
+export { classifyRegion, REGIONS } from './core/region-classifier.js';
+export { scoreCompliance, COMPLIANCE_LEVELS } from './core/compliance-scorer.js';
+
+export { AssessAgent } from './agents/governance/assess-agent.js';
+export { AlignAgent } from './agents/governance/align-agent.js';
+export { AuditAgent } from './agents/governance/audit-agent.js';
+
+export { HeaderAgent } from './agents/standards/header-agent.js';
+export { TagAgent } from './agents/standards/tag-agent.js';
+export { RegionAgent } from './agents/standards/region-agent.js';
+export { DiscoveryPipelineAgent } from './agents/standards/discovery-pipeline-agent.js';
+export { AuthorityAgent } from './agents/standards/authority-agent.js';
+export { PlacementAgent } from './agents/standards/placement-agent.js';
+export { RegistryAgent } from './agents/standards/registry-agent.js';
+
+export { EndpointAgent } from './agents/mcp/endpoint-agent.js';
+export { TransportAgent } from './agents/mcp/transport-agent.js';
+export { PortAgent } from './agents/mcp/port-agent.js';
+export { ProcessAgent } from './agents/mcp/process-agent.js';
+export { EnvAgent } from './agents/mcp/env-agent.js';
+export { RuntimeAgent } from './agents/mcp/runtime-agent.js';
+export { ManifestAgent } from './agents/mcp/manifest-agent.js';
+export { HealthAgentLite } from './agents/mcp/health-agent-lite.js';
+
+export { SyntaxAgent } from './agents/integrity/syntax-agent.js';
+export { ImportAgent } from './agents/integrity/import-agent.js';
+export { ModulePolicyAgent } from './agents/integrity/module-policy-agent.js';
+export { DuplicateLogicAgent } from './agents/integrity/duplicate-logic-agent.js';
+export { DependencyGraphAgent } from './agents/integrity/dependency-graph-agent.js';
+export { CircularDependencyAgent } from './agents/integrity/circular-dependency-agent.js';
+export { RefactorScanAgent } from './agents/integrity/refactor-scan-agent.js';
+
+export { SecretScanAgent } from './agents/security/secret-scan-agent.js';
+export { PermissionAgent } from './agents/security/permission-agent.js';
+export { PromptSecurityAgent } from './agents/security/prompt-security-agent.js';
+export { ToolAccessAgent } from './agents/security/tool-access-agent.js';
+export { PolicyAgent } from './agents/security/policy-agent.js';
+export { PrivacyAgent } from './agents/security/privacy-agent.js';
+
+export { SchemaAgent } from './agents/discovery/schema-agent.js';
+export { SitemapAgent } from './agents/discovery/sitemap-agent.js';
+export { IntentRegistryAgent } from './agents/discovery/intent-registry-agent.js';
+export { DocsAgent } from './agents/discovery/docs-agent.js';
+export { ExplainAgent } from './agents/discovery/explain-agent.js';
+export { ArchitectureMapAgent } from './agents/discovery/architecture-map-agent.js';
+
+export { RouterAgent } from './agents/orchestration/router-agent.js';
+export { MemoryAgentLite } from './agents/orchestration/memory-agent-lite.js';
+export { DoctorAgent } from './agents/orchestration/doctor-agent.js';

package/README.md

@@ -0,0 +1,217 @@
+# LeeWay Agent Skills
+
+[![GitHub](https://img.shields.io/badge/GitHub-LeeWay--Agent--Skills-181717?logo=github)](https://github.com/4citeB4U/LeeWay-Agent-Skills)
+[![npm](https://img.shields.io/badge/npm-@leeway%2Fagent--skills-CB3837?logo=npm&logoColor=white)](https://www.npmjs.com/package/@leeway/agent-skills)
+[![Node](https://img.shields.io/badge/Node-18%2B-339933?logo=node.js&logoColor=white)](https://nodejs.org/)
+[![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![MCP](https://img.shields.io/badge/MCP-ready-0A7EA4)](mcp-server/README.md)
+
+> The developer-facing skill system for agentic engineering.
+>
+> LeeWay Agent Skills gives developers, AI engineers, platform teams, and product builders a practical way to turn LLM capability into an operating layer: reusable skill modules, callable MCP tools, workflow orchestration, governance automation, and proof-backed integration assets.
+
+## Why This Project Exists
+
+Most AI tooling stops at prompting. LeeWay Agent Skills is built for teams that need more than a clever demo. It packages structured execution knowledge, workflow composition, MCP delivery, and compliance controls into one repository so agentic systems can be deployed with more consistency, more speed, and less operational guesswork.
+
+If you are building internal copilots, engineering assistants, AI-enabled products, platform tooling, or multi-agent systems, this project is designed to help you move from experimentation to repeatable delivery.
+
+## What You Get
+
+| Area | What it delivers |
+| --- | --- |
+| Skill Library | 51 installed skill modules across 27 categories for engineering, QA, AI, security, architecture, workflow composition, and more |
+| MCP Runtime | 44 active MCP-exposed tools today through the packaged skills registry |
+| Workflow Layer | 50+ documented workflow patterns and acquisition plans for orchestration at scale |
+| Standards and Governance | Leeway Standards integration for headers, compliance scanning, remediation, and operational guardrails |
+| NPM Distribution | Installable package and CLI surface via `@leeway/agent-skills` |
+| Integration Proof | Badge bundle generator to visibly prove another application is powered by LeeWay Agent Skills |
+
+## Built For
+
+- Developers building faster with structured AI capabilities instead of ad hoc prompting
+- Engineering organizations that want reusable agent skills with governance built in
+- AI product teams shipping assistants, copilots, internal platforms, or MCP servers
+- Agencies, consultants, and platform teams who need proof-backed AI integration assets
+- Multi-agent and workflow builders who need a growing skill and orchestration layer
+
+## Product Positioning
+
+LeeWay Agent Skills is not just a prompt collection and not just a documentation dump. It is a packaged capability layer for agentic software systems.
+
+It combines:
+
+- A reusable skill library
+- A callable MCP tool surface
+- Workflow composition strategy
+- Governance and compliance automation
+- Badge-driven proof of integration
+- A distribution model that works through GitHub and npm
+
+That combination makes it useful both as an engineering asset and as a platform story you can deploy, demonstrate, and sell internally or externally.
+
+## Quick Start
+
+### Install From npm
+
+```powershell
+npm install @leeway/agent-skills
+```
+
+```powershell
+leeway-agent-skills info
+leeway-agent-skills-mcp
+leeway-agent-skills-badge .\public\leeway-proof "My App" mcp-server
+```
+
+Compatibility aliases are also included:
+
+```powershell
+leeway-skills info
+leeway-skills-mcp
+```
+
+### Clone The Repository
+
+```powershell
+git clone https://github.com/4citeB4U/LeeWay-Agent-Skills.git
+cd LeeWay-Agent-Skills
+npm --prefix mcp-server install
+npm --prefix mcp-server run build
+node .\bin\leeway-skills.js info
+```
+
+### Run The MCP Server
+
+```powershell
+node .\bin\leeway-skills.js mcp
+```
+
+### Generate A Proof-Backed Badge Bundle
+
+```powershell
+node .\bin\leeway-skills.js badge .\public\leeway-proof "My App" mcp-server
+```
+
+## How Developers Use It
+
+| Use case | What LeeWay Agent Skills adds |
+| --- | --- |
+| Internal engineering copilots | Reusable skill modules, clearer execution prompts, and callable tools |
+| CI and delivery automation | Workflow composition patterns for diagnosis, recovery, validation, and release handling |
+| Code generation and review | Structured expertise across TypeScript, Python, testing, architecture, and security |
+| Security and compliance | Standards checks, header enforcement, secret scanning, and remediation helpers |
+| Productized AI platforms | Badge proof bundles and npm distribution for integration into other apps |
+
+## Architecture At A Glance
+
+```text
+Skills -> Workflows -> MCP Tools -> Agents -> Governance -> Proof
+```
+
+```text
+LeeWay Agent Skills
+  |- skills/                 reusable capability modules
+  |- mcp-server/             packaged Model Context Protocol server
+  |- LeeWay-Standards/       governance, scanning, and repair tooling
+  |- scripts/                automation and registry utilities
+  |- documents/              strategy, planning, architecture, and rollout docs
+  |- bin/                    package-level developer CLIs
+  `- sdk/                    importable runtime helpers and path utilities
+```
+
+## Core Capabilities
+
+### Skill Library
+
+The `skills/` tree contains the actual operating knowledge for the system. These skills cover code generation, debugging, testing, infrastructure, AI/ML, architecture, security, research, workflow composition, and more.
+
+### MCP Server
+
+The packaged MCP server exposes the active skill registry as callable tools so LLMs and agent frameworks can interact with the system as runtime capabilities instead of static reference text.
+
+Start here: [mcp-server/README.md](mcp-server/README.md)
+
+### Workflow Strategy
+
+LeeWay Agent Skills includes workflow planning and orchestration strategy for higher-order execution, including pre-composed bundles for CI recovery, reporting, coordination, analysis, and agent collaboration.
+
+Start here: [documents/LEEWAY_WORKFLOWS_STRATEGIC_PLAN.md](documents/LEEWAY_WORKFLOWS_STRATEGIC_PLAN.md)
+
+### Governance And Standards
+
+The project integrates Leeway Standards so teams can add headers, scan compliance posture, and improve consistency across files, agents, and automation pipelines.
+
+Start here: [documents/LEEWAY_STANDARDS_COMPLIANCE.md](documents/LEEWAY_STANDARDS_COMPLIANCE.md)
+
+### Badge And Proof Integration
+
+If another application uses LeeWay Agent Skills, the badge tooling can generate visible proof files and embeddable assets so usage is not hidden or hand-wavy.
+
+Start here: [documents/LEEWAY_BADGE_INTEGRATION.md](documents/LEEWAY_BADGE_INTEGRATION.md)
+
+## Repository Guide
+
+| Path | Purpose |
+| --- | --- |
+| `README.md` | Project overview, positioning, and developer onboarding |
+| `package.json` | Root npm package for `@leeway/agent-skills` |
+| `skills/` | Installed skill library |
+| `mcp-server/` | MCP runtime source and packaged build output |
+| `LeeWay-Standards/` | Governance toolkit and CLI |
+| `scripts/` | Registry, compliance, bootstrap, and workflow tooling |
+| `documents/` | Strategic, technical, and operational documentation |
+| `sdk/` | Importable helpers for packaged consumers |
+| `bin/` | CLI entrypoints for package users |
+
+## Documentation Map
+
+- [NPM SDK Guide](documents/LEEWAY_NPM_SDK.md)
+- [MCP Architecture](documents/MCP_ARCHITECTURE.md)
+- [Agent Lee Integration](documents/AGENT_LEE_INTEGRATION.md)
+- [Leeway Standards Compliance](documents/LEEWAY_STANDARDS_COMPLIANCE.md)
+- [Workflow Strategic Plan](documents/LEEWAY_WORKFLOWS_STRATEGIC_PLAN.md)
+- [Skill Acquisition Executive Summary](documents/SKILL_ACQUISITION_EXECUTIVE_SUMMARY.md)
+
+## Current Status
+
+| Signal | Status |
+| --- | --- |
+| Repository path | `C:\Tools\LeeWay-AgentSkills` |
+| Package name | `@leeway/agent-skills` |
+| Installed skill modules | 51 |
+| Installed categories | 27 |
+| Active MCP tools in registry | 44 |
+| Workflow roadmap | 50+ documented patterns |
+| Expansion roadmap | 250+ target skill acquisition plan |
+
+## Roadmap
+
+- Sync the active registry to fully reflect all installed skills
+- Publish and stabilize the npm package lifecycle
+- Expand toward the 250+ skill acquisition roadmap
+- Add more production-ready workflow bundles and integration examples
+- Strengthen productized deployment stories for internal AI platforms and external SaaS products
+
+## Why It Matters For Engineering Leaders
+
+LeeWay Agent Skills gives technical teams a cleaner answer to a hard problem: how do you make AI behavior more reusable, inspectable, composable, and governable?
+
+This repository answers that with a system developers can actually adopt:
+
+- installable
+- inspectable
+- documentable
+- extensible
+- compatible with MCP
+- aligned with governance
+
+That makes it easier to turn AI from a fragile experiment into an engineering capability.
+
+## Contributing
+
+Contributions should preserve the structure of the skill system, keep non-README markdown inside `documents/`, and maintain compatibility with the Leeway Standards governance model.
+
+## License
+
+MIT. See [LICENSE](LICENSE).