@chemx/starter-kit 26.9.14-205 → 26.9.16-41

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Xopher Pollard / Chemical X Protocol
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -30,9 +30,21 @@ starter-kit/
     └── index.js                # Interactive capsule generator
 ```
 
+## Release Versioning: Minute-Precision CalVer
+
+This package adheres to **Minute-Precision Calendar Versioning** (`YY.MM.DD-MMMM`):
+- `YY.MM.DD`: Release date (e.g. `26.9.14` for Sept 14, 2026).
+- `MMMM`: Minute of the day (0 to 1439).
+
+Because autonomous coding agent models update frequently, this package is continuously integrated and deployed via automated CI whenever new agent directives, AST checks, or framework rules are tuned. Rapid version iterations reflect active, daily alignment rather than breaking SemVer shifts.
+
+> [!NOTE]
+> Download statistics on npm reflect continuous automated test matrix verification and test runner execution across automated environments.
+
 ---
 
-## Licensing & Access
+## License
 
-Unlocked for verified GitHub Sponsors and VIP license key holders of `chemical-x-protocol`.  
-Explore activation details at [https://chemicalx.xophz.com/#starter-kit](https://chemicalx.xophz.com/#starter-kit).
+Core CLI tools and capsule generators are distributed under the **MIT License**.  
+Private production monorepos and extended starter suites are unlocked for verified GitHub Sponsors.  
+Explore sponsorship details at [https://chemicalx.xophz.com](https://chemicalx.xophz.com).

package/cli/audit/autofix.js

@@ -0,0 +1,177 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+const IGNORED_DIRS = new Set([
+  'node_modules',
+  'dist',
+  'build',
+  'vendor',
+  '.git',
+  '.next',
+  '.turbo',
+  '.cache'
+]);
+
+const FIXABLE_EXTENSIONS = new Set(['.tsx', '.ts', '.jsx', '.js', '.vue', '.md', '.scss', '.css']);
+
+const RESIDUE_PATTERNS = [
+  'hope this helps',
+  'feel free to tweak',
+  'let me know if you need',
+  'as an ai language model'
+];
+
+const RESIDUE_REGEX = new RegExp(`\\b(?:${RESIDUE_PATTERNS.join('|')})\\b`, 'i');
+const PREAMBLE_REGEX = /\b(?:here(?:'s| is) the (?:complete|updated|refactored|full) (?:code|implementation|file|component|version))\b/i;
+const TRUNCATION_REGEX = /^\s*\/\/\s*\.\.\.\s*(?:existing|rest of|remaining)\s+(?:code|implementation|logic|imports)/i;
+const MARKDOWN_FENCE_REGEX = /^\s*```(?:typescript|javascript|tsx|jsx|vue|js|ts|html|css|scss)?\s*$/;
+
+export const autofixContent = (content, options = {}) => {
+  const allowedRules = options.rules ? new Set(options.rules) : null;
+  const shouldFix = (rule) => !allowedRules || allowedRules.has(rule);
+
+  const lines = content.split('\n');
+  const fixes = [];
+  const resultLines = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i];
+    const lineNumber = i + 1;
+    let shouldDropLine = false;
+
+    // 1. Leaked markdown fence removal
+    if (shouldFix('AI_SLOP_CONVERSATIONAL_ARTIFACT') && MARKDOWN_FENCE_REGEX.test(line)) {
+      fixes.push({
+        line: lineNumber,
+        rule: 'AI_SLOP_CONVERSATIONAL_ARTIFACT',
+        action: 'Removed leaked markdown code fence'
+      });
+      shouldDropLine = true;
+    }
+
+    // 2. Pure conversational preamble or residue comment removal
+    if (!shouldDropLine && shouldFix('AI_SLOP_CONVERSATIONAL_ARTIFACT')) {
+      const isComment = /^\s*(?:\/\/|\/\*|<!--)/.test(line);
+      if (isComment && (PREAMBLE_REGEX.test(line) || RESIDUE_REGEX.test(line))) {
+        fixes.push({
+          line: lineNumber,
+          rule: 'AI_SLOP_CONVERSATIONAL_ARTIFACT',
+          action: 'Removed AI conversational residue comment'
+        });
+        shouldDropLine = true;
+      }
+    }
+
+    // 3. AI lazy placeholder comment removal
+    if (!shouldDropLine && shouldFix('AI_SLOP_LAZY_PLACEHOLDER') && TRUNCATION_REGEX.test(line)) {
+      fixes.push({
+        line: lineNumber,
+        rule: 'AI_SLOP_LAZY_PLACEHOLDER',
+        action: 'Removed lazy AI truncation placeholder comment'
+      });
+      shouldDropLine = true;
+    }
+
+    // 4. Typography em dash replacement
+    if (!shouldDropLine && shouldFix('TYPOGRAPHY_EM_DASH') && line.includes('\u2014')) {
+      line = line.replace(/\u2014/g, '-');
+      fixes.push({
+        line: lineNumber,
+        rule: 'TYPOGRAPHY_EM_DASH',
+        action: 'Replaced em dash with standard hyphen'
+      });
+    }
+
+    if (!shouldDropLine) {
+      resultLines.push(line);
+    }
+  }
+
+  return {
+    fixedContent: resultLines.join('\n'),
+    fixes
+  };
+};
+
+const collectFiles = (targetPath, baseDir) => {
+  const stat = fs.statSync(targetPath);
+  if (stat.isFile()) {
+    return [targetPath];
+  }
+
+  let files = [];
+  const entries = fs.readdirSync(targetPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (IGNORED_DIRS.has(entry.name)) continue;
+    const fullPath = path.join(targetPath, entry.name);
+    if (entry.isDirectory()) {
+      files = files.concat(collectFiles(fullPath, baseDir));
+    } else if (FIXABLE_EXTENSIONS.has(path.extname(entry.name))) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+};
+
+export const runAutofix = (targetPath, options = {}) => {
+  const cwd = options.cwd || process.cwd();
+  const resolvedTarget = path.resolve(cwd, targetPath || 'src');
+  const dryRun = Boolean(options.dryRun);
+
+  if (!fs.existsSync(resolvedTarget)) {
+    return {
+      target: targetPath || 'src',
+      dryRun,
+      filesScanned: 0,
+      filesChanged: 0,
+      totalFixes: 0,
+      fixes: []
+    };
+  }
+
+  const files = collectFiles(resolvedTarget, cwd);
+  const allFixes = [];
+  let filesChanged = 0;
+
+  for (const filePath of files) {
+    const relPath = path.relative(cwd, filePath);
+    const originalContent = fs.readFileSync(filePath, 'utf-8');
+    const { fixedContent, fixes } = autofixContent(originalContent, options);
+
+    if (fixes.length > 0) {
+      filesChanged += 1;
+      for (const fix of fixes) {
+        allFixes.push({
+          file: relPath,
+          line: fix.line,
+          rule: fix.rule,
+          action: fix.action
+        });
+      }
+
+      if (!dryRun) {
+        fs.writeFileSync(filePath, fixedContent, 'utf-8');
+      }
+    }
+  }
+
+  // Token optimization: cap fixes list to top 15 samples if very large
+  const MAX_REPORTED_FIXES = 15;
+  const isCapped = allFixes.length > MAX_REPORTED_FIXES;
+  const reportedFixes = isCapped ? allFixes.slice(0, MAX_REPORTED_FIXES) : allFixes;
+
+  const result = {
+    target: targetPath || 'src',
+    dryRun,
+    filesScanned: files.length,
+    filesChanged,
+    totalFixes: allFixes.length,
+    fixes: reportedFixes
+  };
+
+  if (isCapped) {
+    result.omittedFixesCount = allFixes.length - MAX_REPORTED_FIXES;
+  }
+
+  return result;
+};

package/cli/audit/autofix.spec.js

@@ -0,0 +1,85 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { autofixContent, runAutofix } from './autofix.js';
+
+test('autofixContent: replaces em dash with standard hyphen', () => {
+  const input = 'const title = "Welcome — User Dashboard";\n// Notes — see section 3';
+  const { fixedContent, fixes } = autofixContent(input);
+
+  assert.equal(fixes.length, 2);
+  assert.equal(fixes[0].rule, 'TYPOGRAPHY_EM_DASH');
+  assert.equal(fixedContent, 'const title = "Welcome - User Dashboard";\n// Notes - see section 3');
+});
+
+test('autofixContent: removes leaked markdown code fences', () => {
+  const input = '```typescript\nimport { ref } from "vue";\n```';
+  const { fixedContent, fixes } = autofixContent(input);
+
+  assert.equal(fixes.length, 2);
+  assert.equal(fixes[0].rule, 'AI_SLOP_CONVERSATIONAL_ARTIFACT');
+  assert.equal(fixes[1].rule, 'AI_SLOP_CONVERSATIONAL_ARTIFACT');
+  assert.equal(fixedContent, 'import { ref } from "vue";');
+});
+
+test('autofixContent: removes conversational residue comments and preambles', () => {
+  const input = [
+    '// Here is the complete code:',
+    'export const add = (a, b) => a + b;',
+    '// Hope this helps! Feel free to tweak as needed.'
+  ].join('\n');
+
+  const { fixedContent, fixes } = autofixContent(input);
+  assert.equal(fixes.length, 2);
+  assert.equal(fixes[0].rule, 'AI_SLOP_CONVERSATIONAL_ARTIFACT');
+  assert.equal(fixes[1].rule, 'AI_SLOP_CONVERSATIONAL_ARTIFACT');
+  assert.equal(fixedContent, 'export const add = (a, b) => a + b;');
+});
+
+test('autofixContent: removes lazy truncation comments', () => {
+  const input = [
+    'export const config = {',
+    '  // ... existing code',
+    '  timeout: 5000',
+    '};'
+  ].join('\n');
+
+  const { fixedContent, fixes } = autofixContent(input);
+  assert.equal(fixes.length, 1);
+  assert.equal(fixes[0].rule, 'AI_SLOP_LAZY_PLACEHOLDER');
+  assert.equal(fixedContent, 'export const config = {\n  timeout: 5000\n};');
+});
+
+test('autofixContent: respects rule filtering', () => {
+  const input = '```\nconst x = "foo — bar";';
+  const { fixedContent, fixes } = autofixContent(input, { rules: ['TYPOGRAPHY_EM_DASH'] });
+
+  assert.equal(fixes.length, 1);
+  assert.equal(fixes[0].rule, 'TYPOGRAPHY_EM_DASH');
+  assert.ok(fixedContent.includes('```'));
+  assert.ok(fixedContent.includes('foo - bar'));
+});
+
+test('runAutofix: handles dryRun and file write correctly', () => {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'chemx-autofix-test-'));
+  const testFile = path.join(tempDir, 'test.ts');
+  fs.writeFileSync(testFile, 'const msg = "test — em dash";\n// hope this helps', 'utf-8');
+
+  // Dry run: reports fixes without modifying file
+  const dryResult = runAutofix(testFile, { dryRun: true, cwd: tempDir });
+  assert.equal(dryResult.filesChanged, 1);
+  assert.equal(dryResult.totalFixes, 2);
+  assert.equal(dryResult.dryRun, true);
+  assert.equal(fs.readFileSync(testFile, 'utf-8'), 'const msg = "test — em dash";\n// hope this helps');
+
+  // Live run: writes changes
+  const liveResult = runAutofix(testFile, { dryRun: false, cwd: tempDir });
+  assert.equal(liveResult.filesChanged, 1);
+  assert.equal(liveResult.totalFixes, 2);
+  assert.equal(liveResult.dryRun, false);
+  assert.equal(fs.readFileSync(testFile, 'utf-8'), 'const msg = "test - em dash";');
+
+  fs.rmSync(tempDir, { recursive: true, force: true });
+});

package/cli/audit/pattern-detector.js

@@ -73,6 +73,7 @@ export const createPatternRegistry = () => {
         totalHits: bucket.occurrences.length,
         hasHotspot,
         impactScore,
+        uniqueFiles,
         occurrences: bucket.occurrences
       });
     }
@@ -83,6 +84,150 @@ export const createPatternRegistry = () => {
   return { record, resolveHarmonizationCandidates };
 };
 
+const VOID_ELEMENTS = new Set([
+  'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'
+]);
+
+export const extractTemplateTokens = (html) => {
+  const tokens = [];
+  let i = 0;
+  let line = 1;
+
+  while (i < html.length) {
+    if (html[i] === '\n') {
+      line++;
+      i++;
+      continue;
+    }
+
+    if (html.startsWith('<!--', i)) {
+      const endComment = html.indexOf('-->', i + 4);
+      if (endComment === -1) break;
+      for (let c = i; c < endComment + 3; c++) {
+        if (html[c] === '\n') line++;
+      }
+      i = endComment + 3;
+      continue;
+    }
+
+    if (html[i] === '<') {
+      const tagLine = line;
+      let j = i + 1;
+      const isClosing = html[j] === '/';
+      if (isClosing) j++;
+
+      const nameStart = j;
+      while (j < html.length && /[a-zA-Z0-9_-]/.test(html[j])) {
+        j++;
+      }
+      const tagName = html.slice(nameStart, j);
+
+      if (tagName) {
+        let isSelfClosing = false;
+        let inQuote = null;
+
+        while (j < html.length) {
+          const ch = html[j];
+          if (ch === '\n') line++;
+
+          if (inQuote) {
+            if (ch === inQuote && html[j - 1] !== '\\') {
+              inQuote = null;
+            }
+          } else {
+            if (ch === '"' || ch === "'") {
+              inQuote = ch;
+            } else if (ch === '/' && html[j + 1] === '>') {
+              isSelfClosing = true;
+              j += 2;
+              break;
+            } else if (ch === '>') {
+              j++;
+              break;
+            }
+          }
+          j++;
+        }
+
+        const isVoid = VOID_ELEMENTS.has(tagName.toLowerCase());
+        tokens.push({
+          tag: tagName,
+          isClosing,
+          isSelfClosing: isSelfClosing || isVoid,
+          line: tagLine
+        });
+
+        i = j;
+        continue;
+      }
+    }
+
+    i++;
+  }
+
+  return tokens;
+};
+
+export const buildTagTree = (tokens) => {
+  const root = { tag: 'ROOT', line: 1, children: [] };
+  const stack = [root];
+
+  for (const token of tokens) {
+    if (token.isClosing) {
+      for (let s = stack.length - 1; s > 0; s--) {
+        if (stack[s].tag === token.tag) {
+          stack.length = s;
+          break;
+        }
+      }
+    } else {
+      const node = { tag: token.tag, line: token.line, children: [] };
+      stack[stack.length - 1].children.push(node);
+      if (!token.isSelfClosing) {
+        stack.push(node);
+      }
+    }
+  }
+
+  return root.children;
+};
+
+const getHierarchy = (node, depth = 0) => {
+  if (depth > 2 || !node) return '';
+  const childHierarchy = (node.children || [])
+    .map((c) => getHierarchy(c, depth + 1))
+    .filter(Boolean);
+  if (childHierarchy.length === 0) return node.tag;
+  return `${node.tag}>(${childHierarchy.join('+')})`;
+};
+
+export const recordTemplatePatterns = (registry, templateHtml, relativePath, startLineOffset = 0) => {
+  if (!registry || !templateHtml) return;
+  const tokens = extractTemplateTokens(templateHtml);
+  const nodes = buildTagTree(tokens);
+
+  const traverseNodes = (nodeList) => {
+    for (const node of nodeList) {
+      if (node.children && node.children.length >= MIN_CHILD_NODES) {
+        const hierarchy = getHierarchy(node);
+        if (hierarchy && hierarchy.includes('>')) {
+          registry.record('UI_STRUCTURE', hierarchy, {
+            filePath: relativePath,
+            line: node.line + startLineOffset,
+            detail: hierarchy
+          });
+        }
+      }
+      if (node.children && node.children.length > 0) {
+        traverseNodes(node.children);
+      }
+    }
+  };
+
+  traverseNodes(nodes);
+};
+
+
 export const createPatternVisitors = (registry, relativePath) => {
   if (!registry) return {};
 

package/cli/audit/pattern-detector.spec.js

@@ -0,0 +1,61 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  createPatternRegistry,
+  extractTemplateTokens,
+  buildTagTree,
+  recordTemplatePatterns
+} from './pattern-detector.js';
+
+test('extractTemplateTokens: extracts tags, ignoring comments and handling quotes', () => {
+  const html = `
+    <!-- comment -->
+    <v-card class="elevation-2" :title="count > 0 ? 'yes' : 'no'">
+      <v-card-title>Title</v-card-title>
+      <x-btn />
+    </v-card>
+  `;
+
+  const tokens = extractTemplateTokens(html);
+  assert.equal(tokens[0].tag, 'v-card');
+  assert.equal(tokens[0].isClosing, false);
+  assert.equal(tokens[1].tag, 'v-card-title');
+  assert.equal(tokens[2].tag, 'v-card-title');
+  assert.equal(tokens[2].isClosing, true);
+  assert.equal(tokens[3].tag, 'x-btn');
+  assert.equal(tokens[3].isSelfClosing, true);
+  assert.equal(tokens[4].tag, 'v-card');
+  assert.equal(tokens[4].isClosing, true);
+});
+
+test('buildTagTree and recordTemplatePatterns: captures UI_STRUCTURE from Vue template', () => {
+  const registry = createPatternRegistry();
+  const template1 = `
+    <template>
+      <v-sheet class="panel">
+        <x-btn color="primary">Save</x-btn>
+        <x-btn color="secondary">Cancel</x-btn>
+      </v-sheet>
+    </template>
+  `;
+
+  const template2 = `
+    <template>
+      <v-sheet class="controls">
+        <x-btn color="error">Delete</x-btn>
+        <x-btn color="warning">Reset</x-btn>
+      </v-sheet>
+    </template>
+  `;
+
+  recordTemplatePatterns(registry, template1, 'src/components/A.vue');
+  recordTemplatePatterns(registry, template2, 'src/components/B.vue');
+
+  const candidates = registry.resolveHarmonizationCandidates();
+  const uiCandidate = candidates.find((c) => c.type === 'UI_STRUCTURE');
+
+  assert.ok(uiCandidate, 'Expected UI_STRUCTURE candidate to be found');
+  assert.equal(uiCandidate.detail, 'v-sheet>(x-btn+x-btn)');
+  assert.equal(uiCandidate.fileCount, 2);
+  assert.deepEqual(uiCandidate.uniqueFiles.sort(), ['src/components/A.vue', 'src/components/B.vue']);
+});